G__Eve1.cxx

Go to the documentation of this file.

//
// File generated by core/utils/src/rootcint_tmp at Wed Apr 20 13:52:19 2011

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

#define R__DICTIONARY_FILENAME graf3ddIevedIsrcdIG__Eve1
#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__Eve1.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 ::TEveParamList TEveParamList;
      #else
      class TEveParamList  :  public ::TEveElement,  public ::TNamed,  public ::TQObject {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TEveParamList::FloatConfig_t FloatConfig_t;
         #else
         class FloatConfig_t  {
            public:
            //friend XX;
            float fValue; //
            float fMin; //
            float fMax; //
            ::TString fName; //
            bool fSelector; //
         };
         #endif

         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TEveParamList::IntConfig_t IntConfig_t;
         #else
         class IntConfig_t  {
            public:
            //friend XX;
            int fValue; //
            int fMin; //
            int fMax; //
            ::TString fName; //
            bool fSelector; //
         };
         #endif

         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TEveParamList::BoolConfig_t BoolConfig_t;
         #else
         class BoolConfig_t  {
            public:
            //friend XX;
            bool fValue; //
            ::TString fName; //
         };
         #endif

         typedef ::std::vector< ::TEveParamList::FloatConfig_t, ::allocator< ::TEveParamList::FloatConfig_t> > FloatConfigVec_t;
         typedef ::std::vector< ::TEveParamList::FloatConfig_t, ::allocator< ::TEveParamList::FloatConfig_t> >::iterator FloatConfigVec_i;
         typedef ::std::vector< ::TEveParamList::FloatConfig_t, ::allocator< ::TEveParamList::FloatConfig_t> >::iterator FloatConfigVec_ci;
         typedef ::std::vector< ::TEveParamList::IntConfig_t, ::allocator< ::TEveParamList::IntConfig_t> > IntConfigVec_t;
         typedef ::std::vector< ::TEveParamList::IntConfig_t, ::allocator< ::TEveParamList::IntConfig_t> >::iterator IntConfigVec_i;
         typedef ::std::vector< ::TEveParamList::IntConfig_t, ::allocator< ::TEveParamList::IntConfig_t> >::iterator IntConfigVec_ci;
         typedef ::std::vector< ::TEveParamList::BoolConfig_t, ::allocator< ::TEveParamList::BoolConfig_t> > BoolConfigVec_t;
         typedef ::std::vector< ::TEveParamList::BoolConfig_t, ::allocator< ::TEveParamList::BoolConfig_t> >::iterator BoolConfigVec_i;
         typedef ::std::vector< ::TEveParamList::BoolConfig_t, ::allocator< ::TEveParamList::BoolConfig_t> >::iterator BoolConfigVec_ci;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TEveParamList() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TEveVectorT< float > TEveVectorTlEfloatgR;
      #else
      class TEveVectorTlEfloatgR  {
         public:
         //friend XX;
         float fX; //
         float fY; //
         float fZ; //Components of the vector.
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TEveVectorT< double > TEveVectorTlEdoublegR;
      #else
      class TEveVectorTlEdoublegR  {
         public:
         //friend XX;
         double fX; //
         double fY; //
         double fZ; //Components of the vector.
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TEveVector4T< float > TEveVector4TlEfloatgR;
      #else
      class TEveVector4TlEfloatgR  :  public ::TEveVectorT< float > {
         public:
         //friend XX;
         typedef ::TEveVectorT<float> TP;
         float fT; //
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TEveVector4T< double > TEveVector4TlEdoublegR;
      #else
      class TEveVector4TlEdoublegR  :  public ::TEveVectorT< double > {
         public:
         //friend XX;
         typedef ::TEveVectorT<double> TP;
         double fT; //
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TEveVector2T< float > TEveVector2TlEfloatgR;
      #else
      class TEveVector2TlEfloatgR  {
         public:
         //friend XX;
         float fX; //
         float fY; //Components of the point.
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TEveVector2T< double > TEveVector2TlEdoublegR;
      #else
      class TEveVector2TlEdoublegR  {
         public:
         //friend XX;
         double fX; //
         double fY; //Components of the point.
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TEvePathMarkT< float > TEvePathMarkTlEfloatgR;
      #else
      class TEvePathMarkTlEfloatgR  {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TEvePathMarkT< float >::EType_e EType_e;
         #else
         enum EType_e  {
         };
         #endif

         EType_e fType; //Mark-type.
         ::TEveVectorT< float > fV; //Vertex.
         ::TEveVectorT< float > fP; //Momentum.
         ::TEveVectorT< float > fE; //Extra, meaning depends on fType.
         float fTime; //Time.
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TEvePathMarkT< double > TEvePathMarkTlEdoublegR;
      #else
      class TEvePathMarkTlEdoublegR  {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TEvePathMarkT< double >::EType_e EType_e;
         #else
         enum EType_e  {
         };
         #endif

         EType_e fType; //Mark-type.
         ::TEveVectorT< double > fV; //Vertex.
         ::TEveVectorT< double > fP; //Momentum.
         ::TEveVectorT< double > fE; //Extra, meaning depends on fType.
         double fTime; //Time.
      };
      #endif

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

namespace ROOT {
   void TEveElement_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveElement(void *p = 0);
   static void *newArray_TEveElement(Long_t size, void *p);
   static void delete_TEveElement(void *p);
   static void deleteArray_TEveElement(void *p);
   static void destruct_TEveElement(void *p);

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

namespace ROOT {
   void TEveUtil_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveUtil(void *p = 0);
   static void *newArray_TEveUtil(Long_t size, void *p);
   static void delete_TEveUtil(void *p);
   static void deleteArray_TEveUtil(void *p);
   static void destruct_TEveUtil(void *p);

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

namespace ROOT {
   void TEveException_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveException(void *p = 0);
   static void *newArray_TEveException(Long_t size, void *p);
   static void delete_TEveException(void *p);
   static void deleteArray_TEveException(void *p);
   static void destruct_TEveException(void *p);

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

namespace ROOT {
   void TEvePadHolder_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEvePadHolder(void *p);
   static void deleteArray_TEvePadHolder(void *p);
   static void destruct_TEvePadHolder(void *p);

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

namespace ROOT {
   void TEveGeoManagerHolder_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveGeoManagerHolder(void *p = 0);
   static void *newArray_TEveGeoManagerHolder(Long_t size, void *p);
   static void delete_TEveGeoManagerHolder(void *p);
   static void deleteArray_TEveGeoManagerHolder(void *p);
   static void destruct_TEveGeoManagerHolder(void *p);

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

namespace ROOT {
   void TEveRefCnt_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveRefCnt(void *p = 0);
   static void *newArray_TEveRefCnt(Long_t size, void *p);
   static void delete_TEveRefCnt(void *p);
   static void deleteArray_TEveRefCnt(void *p);
   static void destruct_TEveRefCnt(void *p);

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

namespace ROOT {
   void TEveRefBackPtr_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveRefBackPtr(void *p = 0);
   static void *newArray_TEveRefBackPtr(Long_t size, void *p);
   static void delete_TEveRefBackPtr(void *p);
   static void deleteArray_TEveRefBackPtr(void *p);
   static void destruct_TEveRefBackPtr(void *p);

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

namespace ROOT {
   void TEveProjection_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveProjection(void *p);
   static void deleteArray_TEveProjection(void *p);
   static void destruct_TEveProjection(void *p);

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

namespace ROOT {
   void TEveProjected_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveProjected(void *p);
   static void deleteArray_TEveProjected(void *p);
   static void destruct_TEveProjected(void *p);

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

namespace ROOT {
   void TEveProjectionManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveProjectionManager(void *p = 0);
   static void *newArray_TEveProjectionManager(Long_t size, void *p);
   static void delete_TEveProjectionManager(void *p);
   static void deleteArray_TEveProjectionManager(void *p);
   static void destruct_TEveProjectionManager(void *p);

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

namespace ROOT {
   void TEveProjectable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveProjectable(void *p);
   static void deleteArray_TEveProjectable(void *p);
   static void destruct_TEveProjectable(void *p);

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

namespace ROOT {
   void setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator_Dictionary();
   static void *new_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator(void *p = 0);
   static void *newArray_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator(Long_t size, void *p);
   static void delete_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator(void *p);
   static void deleteArray_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator(void *p);
   static void destruct_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*)
   {
      ::set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator),0);
      static ::ROOT::TGenericClassInfo 
         instance("set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator", "prec_stl/set", 89,
                  typeid(::set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator), DefineBehavior(ptr, ptr),
                  0, &setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator_Dictionary, isa_proxy, 0,
                  sizeof(::set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator) );
      instance.SetNew(&new_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator);
      instance.SetNewArray(&newArray_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator);
      instance.SetDelete(&delete_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator);
      instance.SetDeleteArray(&deleteArray_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator);
      instance.SetDestructor(&destruct_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*)
   {
      return GenerateInitInstanceLocal((::set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TEveCompound_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveCompound(void *p = 0);
   static void *newArray_TEveCompound(Long_t size, void *p);
   static void delete_TEveCompound(void *p);
   static void deleteArray_TEveCompound(void *p);
   static void destruct_TEveCompound(void *p);

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

namespace ROOT {
   void TEveTrans_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveTrans(void *p = 0);
   static void *newArray_TEveTrans(Long_t size, void *p);
   static void delete_TEveTrans(void *p);
   static void deleteArray_TEveTrans(void *p);
   static void destruct_TEveTrans(void *p);
   static void streamer_TEveTrans(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TEveManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveManager(void *p);
   static void deleteArray_TEveManager(void *p);
   static void destruct_TEveManager(void *p);

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

namespace ROOT {
   void TEveElementcLcLTEveListTreeInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveElementcLcLTEveListTreeInfo(void *p = 0);
   static void *newArray_TEveElementcLcLTEveListTreeInfo(Long_t size, void *p);
   static void delete_TEveElementcLcLTEveListTreeInfo(void *p);
   static void deleteArray_TEveElementcLcLTEveListTreeInfo(void *p);
   static void destruct_TEveElementcLcLTEveListTreeInfo(void *p);

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

namespace ROOT {
   void listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator_Dictionary();
   static void *new_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator(void *p = 0);
   static void *newArray_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator(Long_t size, void *p);
   static void delete_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator(void *p);
   static void deleteArray_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator(void *p);
   static void destruct_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::list<TEveElement*,allocator<TEveElement*> >::iterator*)
   {
      ::list<TEveElement*,allocator<TEveElement*> >::iterator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::list<TEveElement*,allocator<TEveElement*> >::iterator),0);
      static ::ROOT::TGenericClassInfo 
         instance("list<TEveElement*,allocator<TEveElement*> >::iterator", "prec_stl/list", 84,
                  typeid(::list<TEveElement*,allocator<TEveElement*> >::iterator), DefineBehavior(ptr, ptr),
                  0, &listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator_Dictionary, isa_proxy, 0,
                  sizeof(::list<TEveElement*,allocator<TEveElement*> >::iterator) );
      instance.SetNew(&new_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator);
      instance.SetNewArray(&newArray_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator);
      instance.SetDelete(&delete_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator);
      instance.SetDeleteArray(&deleteArray_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator);
      instance.SetDestructor(&destruct_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::list<TEveElement*,allocator<TEveElement*> >::iterator*)
   {
      return GenerateInitInstanceLocal((::list<TEveElement*,allocator<TEveElement*> >::iterator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::list<TEveElement*,allocator<TEveElement*> >::iterator*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TEveElementObjectPtr_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveElementObjectPtr(void *p);
   static void deleteArray_TEveElementObjectPtr(void *p);
   static void destruct_TEveElementObjectPtr(void *p);

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

namespace ROOT {
   void TEveElementList_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveElementList(void *p = 0);
   static void *newArray_TEveElementList(Long_t size, void *p);
   static void delete_TEveElementList(void *p);
   static void deleteArray_TEveElementList(void *p);
   static void destruct_TEveElementList(void *p);

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

namespace ROOT {
   void TEveElementListProjected_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveElementListProjected(void *p = 0);
   static void *newArray_TEveElementListProjected(Long_t size, void *p);
   static void delete_TEveElementListProjected(void *p);
   static void deleteArray_TEveElementListProjected(void *p);
   static void destruct_TEveElementListProjected(void *p);

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

namespace ROOT {
   void TEveGedEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveGedEditor(void *p = 0);
   static void *newArray_TEveGedEditor(Long_t size, void *p);
   static void delete_TEveGedEditor(void *p);
   static void deleteArray_TEveGedEditor(void *p);
   static void destruct_TEveGedEditor(void *p);

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

namespace ROOT {
   void TEveListTreeItem_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveListTreeItem(void *p);
   static void deleteArray_TEveListTreeItem(void *p);
   static void destruct_TEveListTreeItem(void *p);

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

namespace ROOT {
   void TEveGListTreeEditorFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveGListTreeEditorFrame(void *p = 0);
   static void *newArray_TEveGListTreeEditorFrame(Long_t size, void *p);
   static void delete_TEveGListTreeEditorFrame(void *p);
   static void deleteArray_TEveGListTreeEditorFrame(void *p);
   static void destruct_TEveGListTreeEditorFrame(void *p);

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

namespace ROOT {
   void TEveBrowser_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveBrowser(void *p);
   static void deleteArray_TEveBrowser(void *p);
   static void destruct_TEveBrowser(void *p);

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

namespace ROOT {
   void TEveChunkManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveChunkManager(void *p = 0);
   static void *newArray_TEveChunkManager(Long_t size, void *p);
   static void delete_TEveChunkManager(void *p);
   static void deleteArray_TEveChunkManager(void *p);
   static void destruct_TEveChunkManager(void *p);

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

namespace ROOT {
   void TEveChunkManagercLcLiterator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TEveChunkManagercLcLiterator_Dictionary();
   static void delete_TEveChunkManagercLcLiterator(void *p);
   static void deleteArray_TEveChunkManagercLcLiterator(void *p);
   static void destruct_TEveChunkManagercLcLiterator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEveChunkManager::iterator*)
   {
      ::TEveChunkManager::iterator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TEveChunkManager::iterator),0);
      static ::ROOT::TGenericClassInfo 
         instance("TEveChunkManager::iterator", "include/TEveChunkManager.h", 71,
                  typeid(::TEveChunkManager::iterator), DefineBehavior(ptr, ptr),
                  0, &TEveChunkManagercLcLiterator_Dictionary, isa_proxy, 1,
                  sizeof(::TEveChunkManager::iterator) );
      instance.SetDelete(&delete_TEveChunkManagercLcLiterator);
      instance.SetDeleteArray(&deleteArray_TEveChunkManagercLcLiterator);
      instance.SetDestructor(&destruct_TEveChunkManagercLcLiterator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEveChunkManager::iterator*)
   {
      return GenerateInitInstanceLocal((::TEveChunkManager::iterator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEveChunkManager::iterator*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TEveCompoundProjected_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveCompoundProjected(void *p = 0);
   static void *newArray_TEveCompoundProjected(Long_t size, void *p);
   static void delete_TEveCompoundProjected(void *p);
   static void deleteArray_TEveCompoundProjected(void *p);
   static void destruct_TEveCompoundProjected(void *p);

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

namespace ROOT {
   void TEveTransSubEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveTransSubEditor(void *p);
   static void deleteArray_TEveTransSubEditor(void *p);
   static void destruct_TEveTransSubEditor(void *p);

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

namespace ROOT {
   void TEveElementEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveElementEditor(void *p = 0);
   static void *newArray_TEveElementEditor(Long_t size, void *p);
   static void delete_TEveElementEditor(void *p);
   static void deleteArray_TEveElementEditor(void *p);
   static void destruct_TEveElementEditor(void *p);

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

namespace ROOT {
   void TEveEventManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveEventManager(void *p = 0);
   static void *newArray_TEveEventManager(Long_t size, void *p);
   static void delete_TEveEventManager(void *p);
   static void deleteArray_TEveEventManager(void *p);
   static void destruct_TEveEventManager(void *p);

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

namespace ROOT {
   void TEveGValuatorBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveGValuatorBase(void *p);
   static void deleteArray_TEveGValuatorBase(void *p);
   static void destruct_TEveGValuatorBase(void *p);

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

namespace ROOT {
   void TEveGValuator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveGValuator(void *p);
   static void deleteArray_TEveGValuator(void *p);
   static void destruct_TEveGValuator(void *p);

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

namespace ROOT {
   void TEveGDoubleValuator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveGDoubleValuator(void *p);
   static void deleteArray_TEveGDoubleValuator(void *p);
   static void destruct_TEveGDoubleValuator(void *p);

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

namespace ROOT {
   void TEveGTriVecValuator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveGTriVecValuator(void *p);
   static void deleteArray_TEveGTriVecValuator(void *p);
   static void destruct_TEveGTriVecValuator(void *p);

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

namespace ROOT {
   void TEveGedNameFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveGedNameFrame(void *p = 0);
   static void *newArray_TEveGedNameFrame(Long_t size, void *p);
   static void delete_TEveGedNameFrame(void *p);
   static void deleteArray_TEveGedNameFrame(void *p);
   static void destruct_TEveGedNameFrame(void *p);

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

namespace ROOT {
   void TEveGedNameTextButton_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveGedNameTextButton(void *p);
   static void deleteArray_TEveGedNameTextButton(void *p);
   static void destruct_TEveGedNameTextButton(void *p);

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

namespace ROOT {
   void TEveMacro_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveMacro(void *p = 0);
   static void *newArray_TEveMacro(Long_t size, void *p);
   static void delete_TEveMacro(void *p);
   static void deleteArray_TEveMacro(void *p);
   static void destruct_TEveMacro(void *p);

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

namespace ROOT {
   void TEveSelection_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveSelection(void *p = 0);
   static void *newArray_TEveSelection(Long_t size, void *p);
   static void delete_TEveSelection(void *p);
   static void deleteArray_TEveSelection(void *p);
   static void destruct_TEveSelection(void *p);

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

namespace ROOT {
   void TEveViewer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveViewer(void *p = 0);
   static void *newArray_TEveViewer(Long_t size, void *p);
   static void delete_TEveViewer(void *p);
   static void deleteArray_TEveViewer(void *p);
   static void destruct_TEveViewer(void *p);

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

namespace ROOT {
   void TEveViewerList_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveViewerList(void *p = 0);
   static void *newArray_TEveViewerList(Long_t size, void *p);
   static void delete_TEveViewerList(void *p);
   static void deleteArray_TEveViewerList(void *p);
   static void destruct_TEveViewerList(void *p);

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

namespace ROOT {
   void TEveScene_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveScene(void *p = 0);
   static void *newArray_TEveScene(Long_t size, void *p);
   static void delete_TEveScene(void *p);
   static void deleteArray_TEveScene(void *p);
   static void destruct_TEveScene(void *p);

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

namespace ROOT {
   void TEveSceneList_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveSceneList(void *p = 0);
   static void *newArray_TEveSceneList(Long_t size, void *p);
   static void delete_TEveSceneList(void *p);
   static void deleteArray_TEveSceneList(void *p);
   static void destruct_TEveSceneList(void *p);

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

namespace ROOT {
   void TEveWindowManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveWindowManager(void *p = 0);
   static void *newArray_TEveWindowManager(Long_t size, void *p);
   static void delete_TEveWindowManager(void *p);
   static void deleteArray_TEveWindowManager(void *p);
   static void destruct_TEveWindowManager(void *p);

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

namespace ROOT {
   void TEveManagercLcLTRedrawDisabler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveManagercLcLTRedrawDisabler(void *p);
   static void deleteArray_TEveManagercLcLTRedrawDisabler(void *p);
   static void destruct_TEveManagercLcLTRedrawDisabler(void *p);

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

namespace ROOT {
   void TEveManagercLcLTExceptionHandler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveManagercLcLTExceptionHandler(void *p = 0);
   static void *newArray_TEveManagercLcLTExceptionHandler(Long_t size, void *p);
   static void delete_TEveManagercLcLTExceptionHandler(void *p);
   static void deleteArray_TEveManagercLcLTExceptionHandler(void *p);
   static void destruct_TEveManagercLcLTExceptionHandler(void *p);

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

namespace ROOT {
   void TEvePad_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvePad(void *p = 0);
   static void *newArray_TEvePad(Long_t size, void *p);
   static void delete_TEvePad(void *p);
   static void deleteArray_TEvePad(void *p);
   static void destruct_TEvePad(void *p);

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

namespace ROOT {
   void TEveParamList_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveParamList(void *p = 0);
   static void *newArray_TEveParamList(Long_t size, void *p);
   static void delete_TEveParamList(void *p);
   static void deleteArray_TEveParamList(void *p);
   static void destruct_TEveParamList(void *p);
   static void streamer_TEveParamList(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TEveParamListEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveParamListEditor(void *p = 0);
   static void *newArray_TEveParamListEditor(Long_t size, void *p);
   static void delete_TEveParamListEditor(void *p);
   static void deleteArray_TEveParamListEditor(void *p);
   static void destruct_TEveParamListEditor(void *p);

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

namespace ROOT {
   void TEveParamListcLcLFloatConfig_t_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TEveParamListcLcLFloatConfig_t_Dictionary();
   static void *new_TEveParamListcLcLFloatConfig_t(void *p = 0);
   static void *newArray_TEveParamListcLcLFloatConfig_t(Long_t size, void *p);
   static void delete_TEveParamListcLcLFloatConfig_t(void *p);
   static void deleteArray_TEveParamListcLcLFloatConfig_t(void *p);
   static void destruct_TEveParamListcLcLFloatConfig_t(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEveParamList::FloatConfig_t*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TEveParamList::FloatConfig_t) == sizeof(::ROOT::Shadow::TEveParamList::FloatConfig_t));
      ::TEveParamList::FloatConfig_t *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TEveParamList::FloatConfig_t),0);
      static ::ROOT::TGenericClassInfo 
         instance("TEveParamList::FloatConfig_t", "include/TEveParamList.h", 32,
                  typeid(::TEveParamList::FloatConfig_t), DefineBehavior(ptr, ptr),
                  &TEveParamListcLcLFloatConfig_t_ShowMembers, &TEveParamListcLcLFloatConfig_t_Dictionary, isa_proxy, 4,
                  sizeof(::TEveParamList::FloatConfig_t) );
      instance.SetNew(&new_TEveParamListcLcLFloatConfig_t);
      instance.SetNewArray(&newArray_TEveParamListcLcLFloatConfig_t);
      instance.SetDelete(&delete_TEveParamListcLcLFloatConfig_t);
      instance.SetDeleteArray(&deleteArray_TEveParamListcLcLFloatConfig_t);
      instance.SetDestructor(&destruct_TEveParamListcLcLFloatConfig_t);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEveParamList::FloatConfig_t*)
   {
      return GenerateInitInstanceLocal((::TEveParamList::FloatConfig_t*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEveParamList::FloatConfig_t*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TEveParamListcLcLIntConfig_t_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TEveParamListcLcLIntConfig_t_Dictionary();
   static void *new_TEveParamListcLcLIntConfig_t(void *p = 0);
   static void *newArray_TEveParamListcLcLIntConfig_t(Long_t size, void *p);
   static void delete_TEveParamListcLcLIntConfig_t(void *p);
   static void deleteArray_TEveParamListcLcLIntConfig_t(void *p);
   static void destruct_TEveParamListcLcLIntConfig_t(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEveParamList::IntConfig_t*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TEveParamList::IntConfig_t) == sizeof(::ROOT::Shadow::TEveParamList::IntConfig_t));
      ::TEveParamList::IntConfig_t *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TEveParamList::IntConfig_t),0);
      static ::ROOT::TGenericClassInfo 
         instance("TEveParamList::IntConfig_t", "include/TEveParamList.h", 46,
                  typeid(::TEveParamList::IntConfig_t), DefineBehavior(ptr, ptr),
                  &TEveParamListcLcLIntConfig_t_ShowMembers, &TEveParamListcLcLIntConfig_t_Dictionary, isa_proxy, 4,
                  sizeof(::TEveParamList::IntConfig_t) );
      instance.SetNew(&new_TEveParamListcLcLIntConfig_t);
      instance.SetNewArray(&newArray_TEveParamListcLcLIntConfig_t);
      instance.SetDelete(&delete_TEveParamListcLcLIntConfig_t);
      instance.SetDeleteArray(&deleteArray_TEveParamListcLcLIntConfig_t);
      instance.SetDestructor(&destruct_TEveParamListcLcLIntConfig_t);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEveParamList::IntConfig_t*)
   {
      return GenerateInitInstanceLocal((::TEveParamList::IntConfig_t*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEveParamList::IntConfig_t*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TEveParamListcLcLBoolConfig_t_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TEveParamListcLcLBoolConfig_t_Dictionary();
   static void *new_TEveParamListcLcLBoolConfig_t(void *p = 0);
   static void *newArray_TEveParamListcLcLBoolConfig_t(Long_t size, void *p);
   static void delete_TEveParamListcLcLBoolConfig_t(void *p);
   static void deleteArray_TEveParamListcLcLBoolConfig_t(void *p);
   static void destruct_TEveParamListcLcLBoolConfig_t(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEveParamList::BoolConfig_t*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TEveParamList::BoolConfig_t) == sizeof(::ROOT::Shadow::TEveParamList::BoolConfig_t));
      ::TEveParamList::BoolConfig_t *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TEveParamList::BoolConfig_t),0);
      static ::ROOT::TGenericClassInfo 
         instance("TEveParamList::BoolConfig_t", "include/TEveParamList.h", 60,
                  typeid(::TEveParamList::BoolConfig_t), DefineBehavior(ptr, ptr),
                  &TEveParamListcLcLBoolConfig_t_ShowMembers, &TEveParamListcLcLBoolConfig_t_Dictionary, isa_proxy, 4,
                  sizeof(::TEveParamList::BoolConfig_t) );
      instance.SetNew(&new_TEveParamListcLcLBoolConfig_t);
      instance.SetNewArray(&newArray_TEveParamListcLcLBoolConfig_t);
      instance.SetDelete(&delete_TEveParamListcLcLBoolConfig_t);
      instance.SetDeleteArray(&deleteArray_TEveParamListcLcLBoolConfig_t);
      instance.SetDestructor(&destruct_TEveParamListcLcLBoolConfig_t);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEveParamList::BoolConfig_t*)
   {
      return GenerateInitInstanceLocal((::TEveParamList::BoolConfig_t*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEveParamList::BoolConfig_t*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TEveProjectionAxes_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveProjectionAxes(void *p);
   static void deleteArray_TEveProjectionAxes(void *p);
   static void destruct_TEveProjectionAxes(void *p);

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

namespace ROOT {
   void TEveProjectionAxesEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveProjectionAxesEditor(void *p = 0);
   static void *newArray_TEveProjectionAxesEditor(Long_t size, void *p);
   static void delete_TEveProjectionAxesEditor(void *p);
   static void deleteArray_TEveProjectionAxesEditor(void *p);
   static void destruct_TEveProjectionAxesEditor(void *p);

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

namespace ROOT {
   void TEveProjectionAxesGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveProjectionAxesGL(void *p = 0);
   static void *newArray_TEveProjectionAxesGL(Long_t size, void *p);
   static void delete_TEveProjectionAxesGL(void *p);
   static void deleteArray_TEveProjectionAxesGL(void *p);
   static void destruct_TEveProjectionAxesGL(void *p);

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

namespace ROOT {
   void TEveProjectionManagerEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveProjectionManagerEditor(void *p = 0);
   static void *newArray_TEveProjectionManagerEditor(Long_t size, void *p);
   static void delete_TEveProjectionManagerEditor(void *p);
   static void deleteArray_TEveProjectionManagerEditor(void *p);
   static void destruct_TEveProjectionManagerEditor(void *p);

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

namespace ROOT {
   void TEveVectorTlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TEveVectorTlEfloatgR_Dictionary();
   static void *new_TEveVectorTlEfloatgR(void *p = 0);
   static void *newArray_TEveVectorTlEfloatgR(Long_t size, void *p);
   static void delete_TEveVectorTlEfloatgR(void *p);
   static void deleteArray_TEveVectorTlEfloatgR(void *p);
   static void destruct_TEveVectorTlEfloatgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEveVectorT<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TEveVectorT<float>) == sizeof(::ROOT::Shadow::TEveVectorTlEfloatgR));
      ::TEveVectorT<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEveVectorT<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEveVectorT<float>", ::TEveVectorT<float>::Class_Version(), "include/TEveVector.h", 26,
                  typeid(::TEveVectorT<float>), DefineBehavior(ptr, ptr),
                  &TEveVectorTlEfloatgR_Dictionary, isa_proxy, 4,
                  sizeof(::TEveVectorT<float>) );
      instance.SetNew(&new_TEveVectorTlEfloatgR);
      instance.SetNewArray(&newArray_TEveVectorTlEfloatgR);
      instance.SetDelete(&delete_TEveVectorTlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TEveVectorTlEfloatgR);
      instance.SetDestructor(&destruct_TEveVectorTlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEveVectorT<float>*)
   {
      return GenerateInitInstanceLocal((::TEveVectorT<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEveVectorT<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TEveVectorTlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TEveVectorTlEdoublegR_Dictionary();
   static void *new_TEveVectorTlEdoublegR(void *p = 0);
   static void *newArray_TEveVectorTlEdoublegR(Long_t size, void *p);
   static void delete_TEveVectorTlEdoublegR(void *p);
   static void deleteArray_TEveVectorTlEdoublegR(void *p);
   static void destruct_TEveVectorTlEdoublegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEveVectorT<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TEveVectorT<double>) == sizeof(::ROOT::Shadow::TEveVectorTlEdoublegR));
      ::TEveVectorT<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEveVectorT<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEveVectorT<double>", ::TEveVectorT<double>::Class_Version(), "include/TEveVector.h", 26,
                  typeid(::TEveVectorT<double>), DefineBehavior(ptr, ptr),
                  &TEveVectorTlEdoublegR_Dictionary, isa_proxy, 4,
                  sizeof(::TEveVectorT<double>) );
      instance.SetNew(&new_TEveVectorTlEdoublegR);
      instance.SetNewArray(&newArray_TEveVectorTlEdoublegR);
      instance.SetDelete(&delete_TEveVectorTlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TEveVectorTlEdoublegR);
      instance.SetDestructor(&destruct_TEveVectorTlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEveVectorT<double>*)
   {
      return GenerateInitInstanceLocal((::TEveVectorT<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEveVectorT<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TEveVector4TlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TEveVector4TlEfloatgR_Dictionary();
   static void *new_TEveVector4TlEfloatgR(void *p = 0);
   static void *newArray_TEveVector4TlEfloatgR(Long_t size, void *p);
   static void delete_TEveVector4TlEfloatgR(void *p);
   static void deleteArray_TEveVector4TlEfloatgR(void *p);
   static void destruct_TEveVector4TlEfloatgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEveVector4T<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TEveVector4T<float>) == sizeof(::ROOT::Shadow::TEveVector4TlEfloatgR));
      ::TEveVector4T<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEveVector4T<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEveVector4T<float>", ::TEveVector4T<float>::Class_Version(), "include/TEveVector.h", 213,
                  typeid(::TEveVector4T<float>), DefineBehavior(ptr, ptr),
                  &TEveVector4TlEfloatgR_Dictionary, isa_proxy, 4,
                  sizeof(::TEveVector4T<float>) );
      instance.SetNew(&new_TEveVector4TlEfloatgR);
      instance.SetNewArray(&newArray_TEveVector4TlEfloatgR);
      instance.SetDelete(&delete_TEveVector4TlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TEveVector4TlEfloatgR);
      instance.SetDestructor(&destruct_TEveVector4TlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEveVector4T<float>*)
   {
      return GenerateInitInstanceLocal((::TEveVector4T<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEveVector4T<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TEveVector4TlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TEveVector4TlEdoublegR_Dictionary();
   static void *new_TEveVector4TlEdoublegR(void *p = 0);
   static void *newArray_TEveVector4TlEdoublegR(Long_t size, void *p);
   static void delete_TEveVector4TlEdoublegR(void *p);
   static void deleteArray_TEveVector4TlEdoublegR(void *p);
   static void destruct_TEveVector4TlEdoublegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEveVector4T<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TEveVector4T<double>) == sizeof(::ROOT::Shadow::TEveVector4TlEdoublegR));
      ::TEveVector4T<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEveVector4T<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEveVector4T<double>", ::TEveVector4T<double>::Class_Version(), "include/TEveVector.h", 213,
                  typeid(::TEveVector4T<double>), DefineBehavior(ptr, ptr),
                  &TEveVector4TlEdoublegR_Dictionary, isa_proxy, 4,
                  sizeof(::TEveVector4T<double>) );
      instance.SetNew(&new_TEveVector4TlEdoublegR);
      instance.SetNewArray(&newArray_TEveVector4TlEdoublegR);
      instance.SetDelete(&delete_TEveVector4TlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TEveVector4TlEdoublegR);
      instance.SetDestructor(&destruct_TEveVector4TlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEveVector4T<double>*)
   {
      return GenerateInitInstanceLocal((::TEveVector4T<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEveVector4T<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TEveVector2TlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TEveVector2TlEfloatgR_Dictionary();
   static void *new_TEveVector2TlEfloatgR(void *p = 0);
   static void *newArray_TEveVector2TlEfloatgR(Long_t size, void *p);
   static void delete_TEveVector2TlEfloatgR(void *p);
   static void deleteArray_TEveVector2TlEfloatgR(void *p);
   static void destruct_TEveVector2TlEfloatgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEveVector2T<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TEveVector2T<float>) == sizeof(::ROOT::Shadow::TEveVector2TlEfloatgR));
      ::TEveVector2T<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEveVector2T<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEveVector2T<float>", ::TEveVector2T<float>::Class_Version(), "include/TEveVector.h", 281,
                  typeid(::TEveVector2T<float>), DefineBehavior(ptr, ptr),
                  &TEveVector2TlEfloatgR_Dictionary, isa_proxy, 4,
                  sizeof(::TEveVector2T<float>) );
      instance.SetNew(&new_TEveVector2TlEfloatgR);
      instance.SetNewArray(&newArray_TEveVector2TlEfloatgR);
      instance.SetDelete(&delete_TEveVector2TlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TEveVector2TlEfloatgR);
      instance.SetDestructor(&destruct_TEveVector2TlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEveVector2T<float>*)
   {
      return GenerateInitInstanceLocal((::TEveVector2T<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEveVector2T<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TEveVector2TlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TEveVector2TlEdoublegR_Dictionary();
   static void *new_TEveVector2TlEdoublegR(void *p = 0);
   static void *newArray_TEveVector2TlEdoublegR(Long_t size, void *p);
   static void delete_TEveVector2TlEdoublegR(void *p);
   static void deleteArray_TEveVector2TlEdoublegR(void *p);
   static void destruct_TEveVector2TlEdoublegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEveVector2T<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TEveVector2T<double>) == sizeof(::ROOT::Shadow::TEveVector2TlEdoublegR));
      ::TEveVector2T<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEveVector2T<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEveVector2T<double>", ::TEveVector2T<double>::Class_Version(), "include/TEveVector.h", 281,
                  typeid(::TEveVector2T<double>), DefineBehavior(ptr, ptr),
                  &TEveVector2TlEdoublegR_Dictionary, isa_proxy, 4,
                  sizeof(::TEveVector2T<double>) );
      instance.SetNew(&new_TEveVector2TlEdoublegR);
      instance.SetNewArray(&newArray_TEveVector2TlEdoublegR);
      instance.SetDelete(&delete_TEveVector2TlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TEveVector2TlEdoublegR);
      instance.SetDestructor(&destruct_TEveVector2TlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEveVector2T<double>*)
   {
      return GenerateInitInstanceLocal((::TEveVector2T<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEveVector2T<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TEveProjectioncLcLPreScaleEntry_t_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveProjectioncLcLPreScaleEntry_t(void *p = 0);
   static void *newArray_TEveProjectioncLcLPreScaleEntry_t(Long_t size, void *p);
   static void delete_TEveProjectioncLcLPreScaleEntry_t(void *p);
   static void deleteArray_TEveProjectioncLcLPreScaleEntry_t(void *p);
   static void destruct_TEveProjectioncLcLPreScaleEntry_t(void *p);

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

namespace ROOT {
   void vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator_Dictionary();
   static void *new_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator(void *p = 0);
   static void *newArray_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator(Long_t size, void *p);
   static void delete_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator(void *p);
   static void deleteArray_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator(void *p);
   static void destruct_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*)
   {
      ::vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator", "prec_stl/vector", 218,
                  typeid(::vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator), DefineBehavior(ptr, ptr),
                  0, &vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator_Dictionary, isa_proxy, 0,
                  sizeof(::vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator) );
      instance.SetNew(&new_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator);
      instance.SetNewArray(&newArray_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator);
      instance.SetDelete(&delete_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator);
      instance.SetDeleteArray(&deleteArray_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator);
      instance.SetDestructor(&destruct_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*)
   {
      return GenerateInitInstanceLocal((::vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TEveRhoZProjection_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveRhoZProjection(void *p = 0);
   static void *newArray_TEveRhoZProjection(Long_t size, void *p);
   static void delete_TEveRhoZProjection(void *p);
   static void deleteArray_TEveRhoZProjection(void *p);
   static void destruct_TEveRhoZProjection(void *p);

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

namespace ROOT {
   void TEveRPhiProjection_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveRPhiProjection(void *p = 0);
   static void *newArray_TEveRPhiProjection(Long_t size, void *p);
   static void delete_TEveRPhiProjection(void *p);
   static void deleteArray_TEveRPhiProjection(void *p);
   static void destruct_TEveRPhiProjection(void *p);

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

namespace ROOT {
   void TEve3DProjection_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEve3DProjection(void *p = 0);
   static void *newArray_TEve3DProjection(Long_t size, void *p);
   static void delete_TEve3DProjection(void *p);
   static void deleteArray_TEve3DProjection(void *p);
   static void destruct_TEve3DProjection(void *p);

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

namespace ROOT {
   void TEveSceneInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveSceneInfo(void *p);
   static void deleteArray_TEveSceneInfo(void *p);
   static void destruct_TEveSceneInfo(void *p);

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

namespace ROOT {
   void TEveTransEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveTransEditor(void *p = 0);
   static void *newArray_TEveTransEditor(Long_t size, void *p);
   static void delete_TEveTransEditor(void *p);
   static void deleteArray_TEveTransEditor(void *p);
   static void destruct_TEveTransEditor(void *p);

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

namespace ROOT {
   void TEveSelectorToEventList_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveSelectorToEventList(void *p);
   static void deleteArray_TEveSelectorToEventList(void *p);
   static void destruct_TEveSelectorToEventList(void *p);

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

namespace ROOT {
   void TEvePointSelector_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvePointSelector(void *p = 0);
   static void *newArray_TEvePointSelector(Long_t size, void *p);
   static void delete_TEvePointSelector(void *p);
   static void deleteArray_TEvePointSelector(void *p);
   static void destruct_TEvePointSelector(void *p);

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

namespace ROOT {
   void TEvePointSelectorConsumer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEvePointSelectorConsumer(void *p);
   static void deleteArray_TEvePointSelectorConsumer(void *p);
   static void destruct_TEvePointSelectorConsumer(void *p);

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

namespace ROOT {
   void TEvePathMarkTlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TEvePathMarkTlEfloatgR_Dictionary();
   static void *new_TEvePathMarkTlEfloatgR(void *p = 0);
   static void *newArray_TEvePathMarkTlEfloatgR(Long_t size, void *p);
   static void delete_TEvePathMarkTlEfloatgR(void *p);
   static void deleteArray_TEvePathMarkTlEfloatgR(void *p);
   static void destruct_TEvePathMarkTlEfloatgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvePathMarkT<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TEvePathMarkT<float>) == sizeof(::ROOT::Shadow::TEvePathMarkTlEfloatgR));
      ::TEvePathMarkT<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvePathMarkT<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEvePathMarkT<float>", ::TEvePathMarkT<float>::Class_Version(), "include/TEvePathMark.h", 23,
                  typeid(::TEvePathMarkT<float>), DefineBehavior(ptr, ptr),
                  &TEvePathMarkTlEfloatgR_Dictionary, isa_proxy, 4,
                  sizeof(::TEvePathMarkT<float>) );
      instance.SetNew(&new_TEvePathMarkTlEfloatgR);
      instance.SetNewArray(&newArray_TEvePathMarkTlEfloatgR);
      instance.SetDelete(&delete_TEvePathMarkTlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TEvePathMarkTlEfloatgR);
      instance.SetDestructor(&destruct_TEvePathMarkTlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEvePathMarkT<float>*)
   {
      return GenerateInitInstanceLocal((::TEvePathMarkT<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvePathMarkT<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TEvePathMarkTlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TEvePathMarkTlEdoublegR_Dictionary();
   static void *new_TEvePathMarkTlEdoublegR(void *p = 0);
   static void *newArray_TEvePathMarkTlEdoublegR(Long_t size, void *p);
   static void delete_TEvePathMarkTlEdoublegR(void *p);
   static void deleteArray_TEvePathMarkTlEdoublegR(void *p);
   static void destruct_TEvePathMarkTlEdoublegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEvePathMarkT<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TEvePathMarkT<double>) == sizeof(::ROOT::Shadow::TEvePathMarkTlEdoublegR));
      ::TEvePathMarkT<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEvePathMarkT<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TEvePathMarkT<double>", ::TEvePathMarkT<double>::Class_Version(), "include/TEvePathMark.h", 23,
                  typeid(::TEvePathMarkT<double>), DefineBehavior(ptr, ptr),
                  &TEvePathMarkTlEdoublegR_Dictionary, isa_proxy, 4,
                  sizeof(::TEvePathMarkT<double>) );
      instance.SetNew(&new_TEvePathMarkTlEdoublegR);
      instance.SetNewArray(&newArray_TEvePathMarkTlEdoublegR);
      instance.SetDelete(&delete_TEvePathMarkTlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TEvePathMarkTlEdoublegR);
      instance.SetDestructor(&destruct_TEvePathMarkTlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TEvePathMarkT<double>*)
   {
      return GenerateInitInstanceLocal((::TEvePathMarkT<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEvePathMarkT<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   void TEveMCTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveMCTrack(void *p = 0);
   static void *newArray_TEveMCTrack(Long_t size, void *p);
   static void delete_TEveMCTrack(void *p);
   static void deleteArray_TEveMCTrack(void *p);
   static void destruct_TEveMCTrack(void *p);

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

namespace ROOT {
   void TEveHit_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveHit(void *p = 0);
   static void *newArray_TEveHit(Long_t size, void *p);
   static void delete_TEveHit(void *p);
   static void deleteArray_TEveHit(void *p);
   static void destruct_TEveHit(void *p);

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

namespace ROOT {
   void TEveCluster_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveCluster(void *p = 0);
   static void *newArray_TEveCluster(Long_t size, void *p);
   static void delete_TEveCluster(void *p);
   static void deleteArray_TEveCluster(void *p);
   static void destruct_TEveCluster(void *p);

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

namespace ROOT {
   void TEveRecTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveRecTrack(void *p = 0);
   static void *newArray_TEveRecTrack(Long_t size, void *p);
   static void delete_TEveRecTrack(void *p);
   static void deleteArray_TEveRecTrack(void *p);
   static void destruct_TEveRecTrack(void *p);

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

namespace ROOT {
   void TEveRecKink_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveRecKink(void *p = 0);
   static void *newArray_TEveRecKink(Long_t size, void *p);
   static void delete_TEveRecKink(void *p);
   static void deleteArray_TEveRecKink(void *p);
   static void destruct_TEveRecKink(void *p);

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

namespace ROOT {
   void TEveRecV0_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveRecV0(void *p = 0);
   static void *newArray_TEveRecV0(Long_t size, void *p);
   static void delete_TEveRecV0(void *p);
   static void deleteArray_TEveRecV0(void *p);
   static void destruct_TEveRecV0(void *p);

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

namespace ROOT {
   void TEveRecCascade_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveRecCascade(void *p = 0);
   static void *newArray_TEveRecCascade(Long_t size, void *p);
   static void delete_TEveRecCascade(void *p);
   static void deleteArray_TEveRecCascade(void *p);
   static void destruct_TEveRecCascade(void *p);

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

namespace ROOT {
   void TEveMCRecCrossRef_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveMCRecCrossRef(void *p = 0);
   static void *newArray_TEveMCRecCrossRef(Long_t size, void *p);
   static void delete_TEveMCRecCrossRef(void *p);
   static void deleteArray_TEveMCRecCrossRef(void *p);
   static void destruct_TEveMCRecCrossRef(void *p);

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

namespace ROOT {
   void TEveVSD_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveVSD(void *p = 0);
   static void *newArray_TEveVSD(Long_t size, void *p);
   static void delete_TEveVSD(void *p);
   static void deleteArray_TEveVSD(void *p);
   static void destruct_TEveVSD(void *p);

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

namespace ROOT {
   void TEveWindow_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveWindow(void *p);
   static void deleteArray_TEveWindow(void *p);
   static void destruct_TEveWindow(void *p);

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

namespace ROOT {
   void TEveWindowSlot_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveWindowSlot(void *p = 0);
   static void *newArray_TEveWindowSlot(Long_t size, void *p);
   static void delete_TEveWindowSlot(void *p);
   static void deleteArray_TEveWindowSlot(void *p);
   static void destruct_TEveWindowSlot(void *p);

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

namespace ROOT {
   void TEveWindowFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveWindowFrame(void *p);
   static void deleteArray_TEveWindowFrame(void *p);
   static void destruct_TEveWindowFrame(void *p);

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

namespace ROOT {
   void TEveWindowPack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveWindowPack(void *p);
   static void deleteArray_TEveWindowPack(void *p);
   static void destruct_TEveWindowPack(void *p);

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

namespace ROOT {
   void TEveWindowTab_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveWindowTab(void *p);
   static void deleteArray_TEveWindowTab(void *p);
   static void destruct_TEveWindowTab(void *p);

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

namespace ROOT {
   void TEveCompositeFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveCompositeFrame(void *p);
   static void deleteArray_TEveCompositeFrame(void *p);
   static void destruct_TEveCompositeFrame(void *p);

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

namespace ROOT {
   void TEveCompositeFrameInMainFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveCompositeFrameInMainFrame(void *p);
   static void deleteArray_TEveCompositeFrameInMainFrame(void *p);
   static void destruct_TEveCompositeFrameInMainFrame(void *p);

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

namespace ROOT {
   void TEveCompositeFrameInPack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveCompositeFrameInPack(void *p);
   static void deleteArray_TEveCompositeFrameInPack(void *p);
   static void destruct_TEveCompositeFrameInPack(void *p);

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

namespace ROOT {
   void TEveCompositeFrameInTab_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveCompositeFrameInTab(void *p);
   static void deleteArray_TEveCompositeFrameInTab(void *p);
   static void destruct_TEveCompositeFrameInTab(void *p);

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

namespace ROOT {
   void TEveViewerListEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveViewerListEditor(void *p = 0);
   static void *newArray_TEveViewerListEditor(Long_t size, void *p);
   static void delete_TEveViewerListEditor(void *p);
   static void deleteArray_TEveViewerListEditor(void *p);
   static void destruct_TEveViewerListEditor(void *p);

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

namespace ROOT {
   void TEveWindowEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveWindowEditor(void *p = 0);
   static void *newArray_TEveWindowEditor(Long_t size, void *p);
   static void delete_TEveWindowEditor(void *p);
   static void deleteArray_TEveWindowEditor(void *p);
   static void destruct_TEveWindowEditor(void *p);

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

namespace ROOT {
   void TEveSecondarySelectable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveSecondarySelectable(void *p = 0);
   static void *newArray_TEveSecondarySelectable(Long_t size, void *p);
   static void delete_TEveSecondarySelectable(void *p);
   static void deleteArray_TEveSecondarySelectable(void *p);
   static void destruct_TEveSecondarySelectable(void *p);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//______________________________________________________________________________
template <> TClass *TEveVectorT<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TEveVectorT<float>::Class_Name()
{
   return "TEveVectorT<float>";
}

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

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

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

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

//______________________________________________________________________________
template <> TClass *TEveVectorT<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TEveVectorT<double>::Class_Name()
{
   return "TEveVectorT<double>";
}

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

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

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

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

//______________________________________________________________________________
template <> TClass *TEveVector4T<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TEveVector4T<float>::Class_Name()
{
   return "TEveVector4T<float>";
}

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

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

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

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

//______________________________________________________________________________
template <> TClass *TEveVector4T<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TEveVector4T<double>::Class_Name()
{
   return "TEveVector4T<double>";
}

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

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

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

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

//______________________________________________________________________________
template <> TClass *TEveVector2T<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TEveVector2T<float>::Class_Name()
{
   return "TEveVector2T<float>";
}

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

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

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

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

//______________________________________________________________________________
template <> TClass *TEveVector2T<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TEveVector2T<double>::Class_Name()
{
   return "TEveVector2T<double>";
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//______________________________________________________________________________
template <> TClass *TEvePathMarkT<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TEvePathMarkT<float>::Class_Name()
{
   return "TEvePathMarkT<float>";
}

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

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

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

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

//______________________________________________________________________________
template <> TClass *TEvePathMarkT<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TEvePathMarkT<double>::Class_Name()
{
   return "TEvePathMarkT<double>";
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//______________________________________________________________________________
template <> void TEveVectorT<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveVectorT<float>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveVectorT<float>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveVectorT<float>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void TEveVectorTlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TEveVectorT<float>.
      typedef ::ROOT::Shadow::TEveVectorTlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TEveVectorT<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX", &sobj->fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY", &sobj->fY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ", &sobj->fZ);
   }

}

template <> void TEveVectorT<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TEveVectorTlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveVectorTlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveVectorT<float> : new ::TEveVectorT<float>;
   }
   static void *newArray_TEveVectorTlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveVectorT<float>[nElements] : new ::TEveVectorT<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveVectorTlEfloatgR(void *p) {
      delete ((::TEveVectorT<float>*)p);
   }
   static void deleteArray_TEveVectorTlEfloatgR(void *p) {
      delete [] ((::TEveVectorT<float>*)p);
   }
   static void destruct_TEveVectorTlEfloatgR(void *p) {
      typedef ::TEveVectorT<float> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveVectorT<float>

//______________________________________________________________________________
template <> void TEveVectorT<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveVectorT<double>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveVectorT<double>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveVectorT<double>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void TEveVectorTlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TEveVectorT<double>.
      typedef ::ROOT::Shadow::TEveVectorTlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TEveVectorT<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX", &sobj->fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY", &sobj->fY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ", &sobj->fZ);
   }

}

template <> void TEveVectorT<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TEveVectorTlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveVectorTlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveVectorT<double> : new ::TEveVectorT<double>;
   }
   static void *newArray_TEveVectorTlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveVectorT<double>[nElements] : new ::TEveVectorT<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveVectorTlEdoublegR(void *p) {
      delete ((::TEveVectorT<double>*)p);
   }
   static void deleteArray_TEveVectorTlEdoublegR(void *p) {
      delete [] ((::TEveVectorT<double>*)p);
   }
   static void destruct_TEveVectorTlEdoublegR(void *p) {
      typedef ::TEveVectorT<double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveVectorT<double>

//______________________________________________________________________________
template <> void TEveVector4T<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveVector4T<float>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveVector4T<float>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveVector4T<float>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void TEveVector4TlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TEveVector4T<float>.
      typedef ::ROOT::Shadow::TEveVector4TlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TEveVector4T<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fT", &sobj->fT);
      sobj->TEveVectorT<float>::ShowMembers(R__insp);
   }

}

template <> void TEveVector4T<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TEveVector4TlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveVector4TlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveVector4T<float> : new ::TEveVector4T<float>;
   }
   static void *newArray_TEveVector4TlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveVector4T<float>[nElements] : new ::TEveVector4T<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveVector4TlEfloatgR(void *p) {
      delete ((::TEveVector4T<float>*)p);
   }
   static void deleteArray_TEveVector4TlEfloatgR(void *p) {
      delete [] ((::TEveVector4T<float>*)p);
   }
   static void destruct_TEveVector4TlEfloatgR(void *p) {
      typedef ::TEveVector4T<float> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveVector4T<float>

//______________________________________________________________________________
template <> void TEveVector4T<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveVector4T<double>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveVector4T<double>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveVector4T<double>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void TEveVector4TlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TEveVector4T<double>.
      typedef ::ROOT::Shadow::TEveVector4TlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TEveVector4T<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fT", &sobj->fT);
      sobj->TEveVectorT<double>::ShowMembers(R__insp);
   }

}

template <> void TEveVector4T<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TEveVector4TlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveVector4TlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveVector4T<double> : new ::TEveVector4T<double>;
   }
   static void *newArray_TEveVector4TlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveVector4T<double>[nElements] : new ::TEveVector4T<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveVector4TlEdoublegR(void *p) {
      delete ((::TEveVector4T<double>*)p);
   }
   static void deleteArray_TEveVector4TlEdoublegR(void *p) {
      delete [] ((::TEveVector4T<double>*)p);
   }
   static void destruct_TEveVector4TlEdoublegR(void *p) {
      typedef ::TEveVector4T<double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveVector4T<double>

//______________________________________________________________________________
template <> void TEveVector2T<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveVector2T<float>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveVector2T<float>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveVector2T<float>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void TEveVector2TlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TEveVector2T<float>.
      typedef ::ROOT::Shadow::TEveVector2TlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TEveVector2T<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX", &sobj->fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY", &sobj->fY);
   }

}

template <> void TEveVector2T<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TEveVector2TlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveVector2TlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveVector2T<float> : new ::TEveVector2T<float>;
   }
   static void *newArray_TEveVector2TlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveVector2T<float>[nElements] : new ::TEveVector2T<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveVector2TlEfloatgR(void *p) {
      delete ((::TEveVector2T<float>*)p);
   }
   static void deleteArray_TEveVector2TlEfloatgR(void *p) {
      delete [] ((::TEveVector2T<float>*)p);
   }
   static void destruct_TEveVector2TlEfloatgR(void *p) {
      typedef ::TEveVector2T<float> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveVector2T<float>

//______________________________________________________________________________
template <> void TEveVector2T<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveVector2T<double>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveVector2T<double>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveVector2T<double>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void TEveVector2TlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TEveVector2T<double>.
      typedef ::ROOT::Shadow::TEveVector2TlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TEveVector2T<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX", &sobj->fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY", &sobj->fY);
   }

}

template <> void TEveVector2T<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TEveVector2TlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveVector2TlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveVector2T<double> : new ::TEveVector2T<double>;
   }
   static void *newArray_TEveVector2TlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveVector2T<double>[nElements] : new ::TEveVector2T<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveVector2TlEdoublegR(void *p) {
      delete ((::TEveVector2T<double>*)p);
   }
   static void deleteArray_TEveVector2TlEdoublegR(void *p) {
      delete [] ((::TEveVector2T<double>*)p);
   }
   static void destruct_TEveVector2TlEdoublegR(void *p) {
      typedef ::TEveVector2T<double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveVector2T<double>

//______________________________________________________________________________
template <> void TEvePathMarkT<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEvePathMarkT<float>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEvePathMarkT<float>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEvePathMarkT<float>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void TEvePathMarkTlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TEvePathMarkT<float>.
      typedef ::ROOT::Shadow::TEvePathMarkTlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TEvePathMarkT<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &sobj->fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fV", &sobj->fV);
      R__insp.InspectMember(sobj->fV, "fV.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP", &sobj->fP);
      R__insp.InspectMember(sobj->fP, "fP.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fE", &sobj->fE);
      R__insp.InspectMember(sobj->fE, "fE.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTime", &sobj->fTime);
   }

}

template <> void TEvePathMarkT<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TEvePathMarkTlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvePathMarkTlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEvePathMarkT<float> : new ::TEvePathMarkT<float>;
   }
   static void *newArray_TEvePathMarkTlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEvePathMarkT<float>[nElements] : new ::TEvePathMarkT<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvePathMarkTlEfloatgR(void *p) {
      delete ((::TEvePathMarkT<float>*)p);
   }
   static void deleteArray_TEvePathMarkTlEfloatgR(void *p) {
      delete [] ((::TEvePathMarkT<float>*)p);
   }
   static void destruct_TEvePathMarkTlEfloatgR(void *p) {
      typedef ::TEvePathMarkT<float> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvePathMarkT<float>

//______________________________________________________________________________
template <> void TEvePathMarkT<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEvePathMarkT<double>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEvePathMarkT<double>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEvePathMarkT<double>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void TEvePathMarkTlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TEvePathMarkT<double>.
      typedef ::ROOT::Shadow::TEvePathMarkTlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TEvePathMarkT<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &sobj->fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fV", &sobj->fV);
      R__insp.InspectMember(sobj->fV, "fV.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP", &sobj->fP);
      R__insp.InspectMember(sobj->fP, "fP.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fE", &sobj->fE);
      R__insp.InspectMember(sobj->fE, "fE.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTime", &sobj->fTime);
   }

}

template <> void TEvePathMarkT<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TEvePathMarkTlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvePathMarkTlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEvePathMarkT<double> : new ::TEvePathMarkT<double>;
   }
   static void *newArray_TEvePathMarkTlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEvePathMarkT<double>[nElements] : new ::TEvePathMarkT<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvePathMarkTlEdoublegR(void *p) {
      delete ((::TEvePathMarkT<double>*)p);
   }
   static void deleteArray_TEvePathMarkTlEdoublegR(void *p) {
      delete [] ((::TEvePathMarkT<double>*)p);
   }
   static void destruct_TEvePathMarkTlEdoublegR(void *p) {
      typedef ::TEvePathMarkT<double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvePathMarkT<double>

//______________________________________________________________________________
void TEveTrans::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveTrans.
      TClass *R__cl = ::TEveTrans::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fM[16]", fM);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fA1", &fA1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fA2", &fA2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fA3", &fA3);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAsOK", &fAsOK);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseTrans", &fUseTrans);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEditTrans", &fEditTrans);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEditRotation", &fEditRotation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEditScale", &fEditScale);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveTrans(void *p) {
      return  p ? new(p) ::TEveTrans : new ::TEveTrans;
   }
   static void *newArray_TEveTrans(Long_t nElements, void *p) {
      return p ? new(p) ::TEveTrans[nElements] : new ::TEveTrans[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveTrans(void *p) {
      delete ((::TEveTrans*)p);
   }
   static void deleteArray_TEveTrans(void *p) {
      delete [] ((::TEveTrans*)p);
   }
   static void destruct_TEveTrans(void *p) {
      typedef ::TEveTrans current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TEveTrans(TBuffer &buf, void *obj) {
      ((::TEveTrans*)obj)->::TEveTrans::Streamer(buf);
   }
} // end of namespace ROOT for class ::TEveTrans

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

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

//______________________________________________________________________________
void TEveTransSubEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveTransSubEditor.
      TClass *R__cl = ::TEveTransSubEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrans", &fTrans);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTopHorFrame", &fTopHorFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUseTrans", &fUseTrans);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditTrans", &fEditTrans);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditTransFrame", &fEditTransFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPos", &fPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRot", &fRot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScale", &fScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAutoUpdate", &fAutoUpdate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUpdate", &fUpdate);
      TGVerticalFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveTransSubEditor(void *p) {
      delete ((::TEveTransSubEditor*)p);
   }
   static void deleteArray_TEveTransSubEditor(void *p) {
      delete [] ((::TEveTransSubEditor*)p);
   }
   static void destruct_TEveTransSubEditor(void *p) {
      typedef ::TEveTransSubEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTransSubEditor

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

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

//______________________________________________________________________________
void TEveTransEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveTransEditor.
      TClass *R__cl = ::TEveTransEditor::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_TEveTransEditor(void *p) {
      return  p ? new(p) ::TEveTransEditor : new ::TEveTransEditor;
   }
   static void *newArray_TEveTransEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveTransEditor[nElements] : new ::TEveTransEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveTransEditor(void *p) {
      delete ((::TEveTransEditor*)p);
   }
   static void deleteArray_TEveTransEditor(void *p) {
      delete [] ((::TEveTransEditor*)p);
   }
   static void destruct_TEveTransEditor(void *p) {
      typedef ::TEveTransEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTransEditor

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveUtil(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveUtil : new ::TEveUtil;
   }
   static void *newArray_TEveUtil(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveUtil[nElements] : new ::TEveUtil[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveUtil(void *p) {
      delete ((::TEveUtil*)p);
   }
   static void deleteArray_TEveUtil(void *p) {
      delete [] ((::TEveUtil*)p);
   }
   static void destruct_TEveUtil(void *p) {
      typedef ::TEveUtil current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveUtil

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveException(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveException : new ::TEveException;
   }
   static void *newArray_TEveException(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveException[nElements] : new ::TEveException[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveException(void *p) {
      delete ((::TEveException*)p);
   }
   static void deleteArray_TEveException(void *p) {
      delete [] ((::TEveException*)p);
   }
   static void destruct_TEveException(void *p) {
      typedef ::TEveException current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveException

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEvePadHolder(void *p) {
      delete ((::TEvePadHolder*)p);
   }
   static void deleteArray_TEvePadHolder(void *p) {
      delete [] ((::TEvePadHolder*)p);
   }
   static void destruct_TEvePadHolder(void *p) {
      typedef ::TEvePadHolder current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvePadHolder

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveGeoManagerHolder(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveGeoManagerHolder : new ::TEveGeoManagerHolder;
   }
   static void *newArray_TEveGeoManagerHolder(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveGeoManagerHolder[nElements] : new ::TEveGeoManagerHolder[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveGeoManagerHolder(void *p) {
      delete ((::TEveGeoManagerHolder*)p);
   }
   static void deleteArray_TEveGeoManagerHolder(void *p) {
      delete [] ((::TEveGeoManagerHolder*)p);
   }
   static void destruct_TEveGeoManagerHolder(void *p) {
      typedef ::TEveGeoManagerHolder current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGeoManagerHolder

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveRefCnt(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveRefCnt : new ::TEveRefCnt;
   }
   static void *newArray_TEveRefCnt(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveRefCnt[nElements] : new ::TEveRefCnt[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveRefCnt(void *p) {
      delete ((::TEveRefCnt*)p);
   }
   static void deleteArray_TEveRefCnt(void *p) {
      delete [] ((::TEveRefCnt*)p);
   }
   static void destruct_TEveRefCnt(void *p) {
      typedef ::TEveRefCnt current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveRefCnt

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveRefBackPtr(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveRefBackPtr : new ::TEveRefBackPtr;
   }
   static void *newArray_TEveRefBackPtr(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveRefBackPtr[nElements] : new ::TEveRefBackPtr[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveRefBackPtr(void *p) {
      delete ((::TEveRefBackPtr*)p);
   }
   static void deleteArray_TEveRefBackPtr(void *p) {
      delete [] ((::TEveRefBackPtr*)p);
   }
   static void destruct_TEveRefBackPtr(void *p) {
      typedef ::TEveRefBackPtr current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveRefBackPtr

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

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

//______________________________________________________________________________
void TEveManager::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveManager.
      TClass *R__cl = ::TEveManager::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExcHandler", &fExcHandler);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVizDB", &fVizDB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVizDBReplace", &fVizDBReplace);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVizDBUpdate", &fVizDBUpdate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGeometries", &fGeometries);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGeometryAliases", &fGeometryAliases);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBrowser", &fBrowser);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLTEFrame", &fLTEFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMacroFolder", &fMacroFolder);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWindowManager", &fWindowManager);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fViewers", &fViewers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScenes", &fScenes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGlobalScene", &fGlobalScene);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEventScene", &fEventScene);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentEvent", &fCurrentEvent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRedrawDisabled", &fRedrawDisabled);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFullRedraw", &fFullRedraw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fResetCameras", &fResetCameras);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDropLogicals", &fDropLogicals);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKeepEmptyCont", &fKeepEmptyCont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimerActive", &fTimerActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRedrawTimer", &fRedrawTimer);
      R__insp.InspectMember(fRedrawTimer, "fRedrawTimer.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStampedElements", &fStampedElements);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelection", &fSelection);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHighlight", &fHighlight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOrphanage", &fOrphanage);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseOrphanage", &fUseOrphanage);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveManager(void *p) {
      delete ((::TEveManager*)p);
   }
   static void deleteArray_TEveManager(void *p) {
      delete [] ((::TEveManager*)p);
   }
   static void destruct_TEveManager(void *p) {
      typedef ::TEveManager current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveManager

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveManagercLcLTRedrawDisabler(void *p) {
      delete ((::TEveManager::TRedrawDisabler*)p);
   }
   static void deleteArray_TEveManagercLcLTRedrawDisabler(void *p) {
      delete [] ((::TEveManager::TRedrawDisabler*)p);
   }
   static void destruct_TEveManagercLcLTRedrawDisabler(void *p) {
      typedef ::TEveManager::TRedrawDisabler current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveManager::TRedrawDisabler

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveManagercLcLTExceptionHandler(void *p) {
      return  p ? new(p) ::TEveManager::TExceptionHandler : new ::TEveManager::TExceptionHandler;
   }
   static void *newArray_TEveManagercLcLTExceptionHandler(Long_t nElements, void *p) {
      return p ? new(p) ::TEveManager::TExceptionHandler[nElements] : new ::TEveManager::TExceptionHandler[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveManagercLcLTExceptionHandler(void *p) {
      delete ((::TEveManager::TExceptionHandler*)p);
   }
   static void deleteArray_TEveManagercLcLTExceptionHandler(void *p) {
      delete [] ((::TEveManager::TExceptionHandler*)p);
   }
   static void destruct_TEveManagercLcLTExceptionHandler(void *p) {
      typedef ::TEveManager::TExceptionHandler current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveManager::TExceptionHandler

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

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

//______________________________________________________________________________
void TEveVSD::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveVSD.
      TClass *R__cl = ::TEveVSD::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFile", &fFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDirectory", &fDirectory);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBuffSize", &fBuffSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVerbose", &fVerbose);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTreeK", &fTreeK);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTreeH", &fTreeH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTreeC", &fTreeC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTreeR", &fTreeR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTreeKK", &fTreeKK);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTreeV0", &fTreeV0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTreeCC", &fTreeCC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTreeGI", &fTreeGI);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fK", &fK);
      R__insp.InspectMember(fK, "fK.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fpK", &fpK);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fH", &fH);
      R__insp.InspectMember(fH, "fH.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fpH", &fpH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fC", &fC);
      R__insp.InspectMember(fC, "fC.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fpC", &fpC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fR", &fR);
      R__insp.InspectMember(fR, "fR.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fpR", &fpR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKK", &fKK);
      R__insp.InspectMember(fKK, "fKK.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fpKK", &fpKK);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fV0", &fV0);
      R__insp.InspectMember(fV0, "fV0.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fpV0", &fpV0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCC", &fCC);
      R__insp.InspectMember(fCC, "fCC.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fpCC", &fpCC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGI", &fGI);
      R__insp.InspectMember(fGI, "fGI.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fpGI", &fpGI);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveVSD(void *p) {
      return  p ? new(p) ::TEveVSD : new ::TEveVSD;
   }
   static void *newArray_TEveVSD(Long_t nElements, void *p) {
      return p ? new(p) ::TEveVSD[nElements] : new ::TEveVSD[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveVSD(void *p) {
      delete ((::TEveVSD*)p);
   }
   static void deleteArray_TEveVSD(void *p) {
      delete [] ((::TEveVSD*)p);
   }
   static void destruct_TEveVSD(void *p) {
      typedef ::TEveVSD current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveVSD

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

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

//______________________________________________________________________________
void TEveMCTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveMCTrack.
      TClass *R__cl = ::TEveMCTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabel", &fLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIndex", &fIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvaLabel", &fEvaLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDecayed", &fDecayed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTDecay", &fTDecay);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVDecay", &fVDecay);
      R__insp.InspectMember(fVDecay, "fVDecay.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPDecay", &fPDecay);
      R__insp.InspectMember(fPDecay, "fPDecay.");
      TParticle::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveMCTrack(void *p) {
      return  p ? new(p) ::TEveMCTrack : new ::TEveMCTrack;
   }
   static void *newArray_TEveMCTrack(Long_t nElements, void *p) {
      return p ? new(p) ::TEveMCTrack[nElements] : new ::TEveMCTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveMCTrack(void *p) {
      delete ((::TEveMCTrack*)p);
   }
   static void deleteArray_TEveMCTrack(void *p) {
      delete [] ((::TEveMCTrack*)p);
   }
   static void destruct_TEveMCTrack(void *p) {
      typedef ::TEveMCTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveMCTrack

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveHit(void *p) {
      return  p ? new(p) ::TEveHit : new ::TEveHit;
   }
   static void *newArray_TEveHit(Long_t nElements, void *p) {
      return p ? new(p) ::TEveHit[nElements] : new ::TEveHit[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveHit(void *p) {
      delete ((::TEveHit*)p);
   }
   static void deleteArray_TEveHit(void *p) {
      delete [] ((::TEveHit*)p);
   }
   static void destruct_TEveHit(void *p) {
      typedef ::TEveHit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveHit

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

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

//______________________________________________________________________________
void TEveCluster::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveCluster.
      TClass *R__cl = ::TEveCluster::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDetId", &fDetId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSubdetId", &fSubdetId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabel[3]", fLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fV", &fV);
      R__insp.InspectMember(fV, "fV.");
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveCluster(void *p) {
      return  p ? new(p) ::TEveCluster : new ::TEveCluster;
   }
   static void *newArray_TEveCluster(Long_t nElements, void *p) {
      return p ? new(p) ::TEveCluster[nElements] : new ::TEveCluster[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveCluster(void *p) {
      delete ((::TEveCluster*)p);
   }
   static void deleteArray_TEveCluster(void *p) {
      delete [] ((::TEveCluster*)p);
   }
   static void destruct_TEveCluster(void *p) {
      typedef ::TEveCluster current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCluster

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

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

//______________________________________________________________________________
void TEveRecTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveRecTrack.
      TClass *R__cl = ::TEveRecTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabel", &fLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIndex", &fIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &fStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSign", &fSign);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fV", &fV);
      R__insp.InspectMember(fV, "fV.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP", &fP);
      R__insp.InspectMember(fP, "fP.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBeta", &fBeta);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveRecTrack(void *p) {
      return  p ? new(p) ::TEveRecTrack : new ::TEveRecTrack;
   }
   static void *newArray_TEveRecTrack(Long_t nElements, void *p) {
      return p ? new(p) ::TEveRecTrack[nElements] : new ::TEveRecTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveRecTrack(void *p) {
      delete ((::TEveRecTrack*)p);
   }
   static void deleteArray_TEveRecTrack(void *p) {
      delete [] ((::TEveRecTrack*)p);
   }
   static void destruct_TEveRecTrack(void *p) {
      typedef ::TEveRecTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveRecTrack

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

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

//______________________________________________________________________________
void TEveRecKink::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveRecKink.
      TClass *R__cl = ::TEveRecKink::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVKink", &fVKink);
      R__insp.InspectMember(fVKink, "fVKink.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPMother", &fPMother);
      R__insp.InspectMember(fPMother, "fPMother.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVMother", &fVMother);
      R__insp.InspectMember(fVMother, "fVMother.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPDaughter", &fPDaughter);
      R__insp.InspectMember(fPDaughter, "fPDaughter.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVDaughter", &fVDaughter);
      R__insp.InspectMember(fVDaughter, "fVDaughter.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKinkAngle[3]", fKinkAngle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSign", &fSign);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &fStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKinkLabel[2]", fKinkLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKinkIndex[2]", fKinkIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKinkPdg[2]", fKinkPdg);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveRecKink(void *p) {
      return  p ? new(p) ::TEveRecKink : new ::TEveRecKink;
   }
   static void *newArray_TEveRecKink(Long_t nElements, void *p) {
      return p ? new(p) ::TEveRecKink[nElements] : new ::TEveRecKink[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveRecKink(void *p) {
      delete ((::TEveRecKink*)p);
   }
   static void deleteArray_TEveRecKink(void *p) {
      delete [] ((::TEveRecKink*)p);
   }
   static void destruct_TEveRecKink(void *p) {
      typedef ::TEveRecKink current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveRecKink

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

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

//______________________________________________________________________________
void TEveRecV0::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveRecV0.
      TClass *R__cl = ::TEveRecV0::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &fStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVNeg", &fVNeg);
      R__insp.InspectMember(fVNeg, "fVNeg.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPNeg", &fPNeg);
      R__insp.InspectMember(fPNeg, "fPNeg.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVPos", &fVPos);
      R__insp.InspectMember(fVPos, "fVPos.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPPos", &fPPos);
      R__insp.InspectMember(fPPos, "fPPos.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVCa", &fVCa);
      R__insp.InspectMember(fVCa, "fVCa.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fV0Birth", &fV0Birth);
      R__insp.InspectMember(fV0Birth, "fV0Birth.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabel", &fLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPdg", &fPdg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDLabel[2]", fDLabel);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveRecV0(void *p) {
      return  p ? new(p) ::TEveRecV0 : new ::TEveRecV0;
   }
   static void *newArray_TEveRecV0(Long_t nElements, void *p) {
      return p ? new(p) ::TEveRecV0[nElements] : new ::TEveRecV0[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveRecV0(void *p) {
      delete ((::TEveRecV0*)p);
   }
   static void deleteArray_TEveRecV0(void *p) {
      delete [] ((::TEveRecV0*)p);
   }
   static void destruct_TEveRecV0(void *p) {
      typedef ::TEveRecV0 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveRecV0

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

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

//______________________________________________________________________________
void TEveRecCascade::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveRecCascade.
      TClass *R__cl = ::TEveRecCascade::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &fStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVBac", &fVBac);
      R__insp.InspectMember(fVBac, "fVBac.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPBac", &fPBac);
      R__insp.InspectMember(fPBac, "fPBac.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCascadeVCa", &fCascadeVCa);
      R__insp.InspectMember(fCascadeVCa, "fCascadeVCa.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCascadeBirth", &fCascadeBirth);
      R__insp.InspectMember(fCascadeBirth, "fCascadeBirth.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabel", &fLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPdg", &fPdg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDLabel", &fDLabel);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveRecCascade(void *p) {
      return  p ? new(p) ::TEveRecCascade : new ::TEveRecCascade;
   }
   static void *newArray_TEveRecCascade(Long_t nElements, void *p) {
      return p ? new(p) ::TEveRecCascade[nElements] : new ::TEveRecCascade[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveRecCascade(void *p) {
      delete ((::TEveRecCascade*)p);
   }
   static void deleteArray_TEveRecCascade(void *p) {
      delete [] ((::TEveRecCascade*)p);
   }
   static void destruct_TEveRecCascade(void *p) {
      typedef ::TEveRecCascade current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveRecCascade

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

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

//______________________________________________________________________________
void TEveMCRecCrossRef::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveMCRecCrossRef.
      TClass *R__cl = ::TEveMCRecCrossRef::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsRec", &fIsRec);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasV0", &fHasV0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasKink", &fHasKink);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabel", &fLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNHits", &fNHits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNClus", &fNClus);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveMCRecCrossRef(void *p) {
      return  p ? new(p) ::TEveMCRecCrossRef : new ::TEveMCRecCrossRef;
   }
   static void *newArray_TEveMCRecCrossRef(Long_t nElements, void *p) {
      return p ? new(p) ::TEveMCRecCrossRef[nElements] : new ::TEveMCRecCrossRef[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveMCRecCrossRef(void *p) {
      delete ((::TEveMCRecCrossRef*)p);
   }
   static void deleteArray_TEveMCRecCrossRef(void *p) {
      delete [] ((::TEveMCRecCrossRef*)p);
   }
   static void destruct_TEveMCRecCrossRef(void *p) {
      typedef ::TEveMCRecCrossRef current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveMCRecCrossRef

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

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

//______________________________________________________________________________
void TEveChunkManager::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveChunkManager.
      TClass *R__cl = ::TEveChunkManager::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fS", &fS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fN", &fN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVecSize", &fVecSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCapacity", &fCapacity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChunks", (void*)&fChunks);
      R__insp.InspectMember("vector<TArrayC*>", (void*)&fChunks, "fChunks.", false);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveChunkManager(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveChunkManager : new ::TEveChunkManager;
   }
   static void *newArray_TEveChunkManager(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveChunkManager[nElements] : new ::TEveChunkManager[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveChunkManager(void *p) {
      delete ((::TEveChunkManager*)p);
   }
   static void deleteArray_TEveChunkManager(void *p) {
      delete [] ((::TEveChunkManager*)p);
   }
   static void destruct_TEveChunkManager(void *p) {
      typedef ::TEveChunkManager current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveChunkManager

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveChunkManagercLcLiterator(void *p) {
      delete ((::TEveChunkManager::iterator*)p);
   }
   static void deleteArray_TEveChunkManagercLcLiterator(void *p) {
      delete [] ((::TEveChunkManager::iterator*)p);
   }
   static void destruct_TEveChunkManagercLcLiterator(void *p) {
      typedef ::TEveChunkManager::iterator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveChunkManager::iterator

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

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

//______________________________________________________________________________
void TEveEventManager::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveEventManager.
      TClass *R__cl = ::TEveEventManager::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNewEventCommands", (void*)&fNewEventCommands);
      R__insp.InspectMember("vector<TString>", (void*)&fNewEventCommands, "fNewEventCommands.", false);
      TEveElementList::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveEventManager(void *p) {
      return  p ? new(p) ::TEveEventManager : new ::TEveEventManager;
   }
   static void *newArray_TEveEventManager(Long_t nElements, void *p) {
      return p ? new(p) ::TEveEventManager[nElements] : new ::TEveEventManager[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveEventManager(void *p) {
      delete ((::TEveEventManager*)p);
   }
   static void deleteArray_TEveEventManager(void *p) {
      delete [] ((::TEveEventManager*)p);
   }
   static void destruct_TEveEventManager(void *p) {
      typedef ::TEveEventManager current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveEventManager

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveSelectorToEventList(void *p) {
      delete ((::TEveSelectorToEventList*)p);
   }
   static void deleteArray_TEveSelectorToEventList(void *p) {
      delete [] ((::TEveSelectorToEventList*)p);
   }
   static void destruct_TEveSelectorToEventList(void *p) {
      typedef ::TEveSelectorToEventList current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveSelectorToEventList

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEvePointSelectorConsumer(void *p) {
      delete ((::TEvePointSelectorConsumer*)p);
   }
   static void deleteArray_TEvePointSelectorConsumer(void *p) {
      delete [] ((::TEvePointSelectorConsumer*)p);
   }
   static void destruct_TEvePointSelectorConsumer(void *p) {
      typedef ::TEvePointSelectorConsumer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvePointSelectorConsumer

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

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

//______________________________________________________________________________
void TEvePointSelector::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEvePointSelector.
      TClass *R__cl = ::TEvePointSelector::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTree", &fTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fConsumer", &fConsumer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVarexp", &fVarexp);
      R__insp.InspectMember(fVarexp, "fVarexp.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelection", &fSelection);
      R__insp.InspectMember(fSelection, "fSelection.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSubIdExp", &fSubIdExp);
      R__insp.InspectMember(fSubIdExp, "fSubIdExp.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSubIdNum", &fSubIdNum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInput", &fInput);
      R__insp.InspectMember(fInput, "fInput.");
      TSelectorDraw::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvePointSelector(void *p) {
      return  p ? new(p) ::TEvePointSelector : new ::TEvePointSelector;
   }
   static void *newArray_TEvePointSelector(Long_t nElements, void *p) {
      return p ? new(p) ::TEvePointSelector[nElements] : new ::TEvePointSelector[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvePointSelector(void *p) {
      delete ((::TEvePointSelector*)p);
   }
   static void deleteArray_TEvePointSelector(void *p) {
      delete [] ((::TEvePointSelector*)p);
   }
   static void destruct_TEvePointSelector(void *p) {
      typedef ::TEvePointSelector current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvePointSelector

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

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

//______________________________________________________________________________
void TEveElement::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveElement.
      TClass *R__cl = ::TEveElement::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParents", (void*)&fParents);
      R__insp.InspectMember("TEveElement::List_t", (void*)&fParents, "fParents.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChildren", (void*)&fChildren);
      R__insp.InspectMember("TEveElement::List_t", (void*)&fChildren, "fChildren.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCompound", &fCompound);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVizModel", &fVizModel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVizTag", &fVizTag);
      R__insp.InspectMember(fVizTag, "fVizTag.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumChildren", &fNumChildren);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParentIgnoreCnt", &fParentIgnoreCnt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTopItemCnt", &fTopItemCnt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDenyDestroy", &fDenyDestroy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDestroyOnZeroRefCnt", &fDestroyOnZeroRefCnt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRnrSelf", &fRnrSelf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRnrChildren", &fRnrChildren);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCanEditMainColor", &fCanEditMainColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCanEditMainTransparency", &fCanEditMainTransparency);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCanEditMainTrans", &fCanEditMainTrans);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMainTransparency", &fMainTransparency);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMainColorPtr", &fMainColorPtr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMainTrans", &fMainTrans);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fItems", (void*)&fItems);
      R__insp.InspectMember("TEveElement::sLTI_t", (void*)&fItems, "fItems.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSource", &fSource);
      R__insp.InspectMember(fSource, "fSource.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUserData", &fUserData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPickable", &fPickable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelected", &fSelected);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighlighted", &fHighlighted);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fImpliedSelected", &fImpliedSelected);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fImpliedHighlighted", &fImpliedHighlighted);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCSCBits", &fCSCBits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fChangeBits", &fChangeBits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDestructing", &fDestructing);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveElement(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveElement : new ::TEveElement;
   }
   static void *newArray_TEveElement(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveElement[nElements] : new ::TEveElement[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveElement(void *p) {
      delete ((::TEveElement*)p);
   }
   static void deleteArray_TEveElement(void *p) {
      delete [] ((::TEveElement*)p);
   }
   static void destruct_TEveElement(void *p) {
      typedef ::TEveElement current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveElement

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveElementcLcLTEveListTreeInfo(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveElement::TEveListTreeInfo : new ::TEveElement::TEveListTreeInfo;
   }
   static void *newArray_TEveElementcLcLTEveListTreeInfo(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveElement::TEveListTreeInfo[nElements] : new ::TEveElement::TEveListTreeInfo[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveElementcLcLTEveListTreeInfo(void *p) {
      delete ((::TEveElement::TEveListTreeInfo*)p);
   }
   static void deleteArray_TEveElementcLcLTEveListTreeInfo(void *p) {
      delete [] ((::TEveElement::TEveListTreeInfo*)p);
   }
   static void destruct_TEveElementcLcLTEveListTreeInfo(void *p) {
      typedef ::TEveElement::TEveListTreeInfo current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveElement::TEveListTreeInfo

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveElementObjectPtr(void *p) {
      delete ((::TEveElementObjectPtr*)p);
   }
   static void deleteArray_TEveElementObjectPtr(void *p) {
      delete [] ((::TEveElementObjectPtr*)p);
   }
   static void destruct_TEveElementObjectPtr(void *p) {
      typedef ::TEveElementObjectPtr current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveElementObjectPtr

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveElementList(void *p) {
      return  p ? new(p) ::TEveElementList : new ::TEveElementList;
   }
   static void *newArray_TEveElementList(Long_t nElements, void *p) {
      return p ? new(p) ::TEveElementList[nElements] : new ::TEveElementList[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveElementList(void *p) {
      delete ((::TEveElementList*)p);
   }
   static void deleteArray_TEveElementList(void *p) {
      delete [] ((::TEveElementList*)p);
   }
   static void destruct_TEveElementList(void *p) {
      typedef ::TEveElementList current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveElementList

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveElementListProjected(void *p) {
      return  p ? new(p) ::TEveElementListProjected : new ::TEveElementListProjected;
   }
   static void *newArray_TEveElementListProjected(Long_t nElements, void *p) {
      return p ? new(p) ::TEveElementListProjected[nElements] : new ::TEveElementListProjected[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveElementListProjected(void *p) {
      delete ((::TEveElementListProjected*)p);
   }
   static void deleteArray_TEveElementListProjected(void *p) {
      delete [] ((::TEveElementListProjected*)p);
   }
   static void destruct_TEveElementListProjected(void *p) {
      typedef ::TEveElementListProjected current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveElementListProjected

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

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

//______________________________________________________________________________
void TEveElementEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveElementEditor.
      TClass *R__cl = ::TEveElementEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRE", &fRE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHFrame", &fHFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPreLabel", &fPreLabel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRnrSelf", &fRnrSelf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRnrChildren", &fRnrChildren);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRnrState", &fRnrState);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMainColor", &fMainColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransparency", &fTransparency);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrans", &fTrans);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveElementEditor(void *p) {
      return  p ? new(p) ::TEveElementEditor : new ::TEveElementEditor;
   }
   static void *newArray_TEveElementEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveElementEditor[nElements] : new ::TEveElementEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveElementEditor(void *p) {
      delete ((::TEveElementEditor*)p);
   }
   static void deleteArray_TEveElementEditor(void *p) {
      delete [] ((::TEveElementEditor*)p);
   }
   static void destruct_TEveElementEditor(void *p) {
      typedef ::TEveElementEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveElementEditor

namespace ROOT {
   // Wrappers around operator new
   static void *new_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::list<TEveElement*,allocator<TEveElement*> >::iterator : new ::list<TEveElement*,allocator<TEveElement*> >::iterator;
   }
   static void *newArray_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::list<TEveElement*,allocator<TEveElement*> >::iterator[nElements] : new ::list<TEveElement*,allocator<TEveElement*> >::iterator[nElements];
   }
   // Wrapper around operator delete
   static void delete_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator(void *p) {
      delete ((::list<TEveElement*,allocator<TEveElement*> >::iterator*)p);
   }
   static void deleteArray_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator(void *p) {
      delete [] ((::list<TEveElement*,allocator<TEveElement*> >::iterator*)p);
   }
   static void destruct_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator(void *p) {
      typedef ::list<TEveElement*,allocator<TEveElement*> >::iterator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::list<TEveElement*,allocator<TEveElement*> >::iterator

namespace ROOT {
   // Wrappers around operator new
   static void *new_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator : new ::set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator;
   }
   static void *newArray_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator[nElements] : new ::set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator[nElements];
   }
   // Wrapper around operator delete
   static void delete_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator(void *p) {
      delete ((::set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*)p);
   }
   static void deleteArray_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator(void *p) {
      delete [] ((::set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*)p);
   }
   static void destruct_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator(void *p) {
      typedef ::set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveCompound(void *p) {
      return  p ? new(p) ::TEveCompound : new ::TEveCompound;
   }
   static void *newArray_TEveCompound(Long_t nElements, void *p) {
      return p ? new(p) ::TEveCompound[nElements] : new ::TEveCompound[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveCompound(void *p) {
      delete ((::TEveCompound*)p);
   }
   static void deleteArray_TEveCompound(void *p) {
      delete [] ((::TEveCompound*)p);
   }
   static void destruct_TEveCompound(void *p) {
      typedef ::TEveCompound current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCompound

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveCompoundProjected(void *p) {
      return  p ? new(p) ::TEveCompoundProjected : new ::TEveCompoundProjected;
   }
   static void *newArray_TEveCompoundProjected(Long_t nElements, void *p) {
      return p ? new(p) ::TEveCompoundProjected[nElements] : new ::TEveCompoundProjected[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveCompoundProjected(void *p) {
      delete ((::TEveCompoundProjected*)p);
   }
   static void deleteArray_TEveCompoundProjected(void *p) {
      delete [] ((::TEveCompoundProjected*)p);
   }
   static void destruct_TEveCompoundProjected(void *p) {
      typedef ::TEveCompoundProjected current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCompoundProjected

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

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

//______________________________________________________________________________
void TEveSelection::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveSelection.
      TClass *R__cl = ::TEveSelection::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPickToSelect", &fPickToSelect);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActive", &fActive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsMaster", &fIsMaster);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fImpliedSelected", (void*)&fImpliedSelected);
      R__insp.InspectMember("TEveSelection::SelMap_t", (void*)&fImpliedSelected, "fImpliedSelected.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelElement", &fSelElement);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIncImpSelElement", &fIncImpSelElement);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDecImpSelElement", &fDecImpSelElement);
      TEveElementList::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveSelection(void *p) {
      return  p ? new(p) ::TEveSelection : new ::TEveSelection;
   }
   static void *newArray_TEveSelection(Long_t nElements, void *p) {
      return p ? new(p) ::TEveSelection[nElements] : new ::TEveSelection[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveSelection(void *p) {
      delete ((::TEveSelection*)p);
   }
   static void deleteArray_TEveSelection(void *p) {
      delete [] ((::TEveSelection*)p);
   }
   static void destruct_TEveSelection(void *p) {
      typedef ::TEveSelection current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveSelection

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveSecondarySelectable(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveSecondarySelectable : new ::TEveSecondarySelectable;
   }
   static void *newArray_TEveSecondarySelectable(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveSecondarySelectable[nElements] : new ::TEveSecondarySelectable[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveSecondarySelectable(void *p) {
      delete ((::TEveSecondarySelectable*)p);
   }
   static void deleteArray_TEveSecondarySelectable(void *p) {
      delete [] ((::TEveSecondarySelectable*)p);
   }
   static void destruct_TEveSecondarySelectable(void *p) {
      typedef ::TEveSecondarySelectable current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveSecondarySelectable

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveScene(void *p) {
      return  p ? new(p) ::TEveScene : new ::TEveScene;
   }
   static void *newArray_TEveScene(Long_t nElements, void *p) {
      return p ? new(p) ::TEveScene[nElements] : new ::TEveScene[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveScene(void *p) {
      delete ((::TEveScene*)p);
   }
   static void deleteArray_TEveScene(void *p) {
      delete [] ((::TEveScene*)p);
   }
   static void destruct_TEveScene(void *p) {
      typedef ::TEveScene current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveScene

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveSceneList(void *p) {
      return  p ? new(p) ::TEveSceneList : new ::TEveSceneList;
   }
   static void *newArray_TEveSceneList(Long_t nElements, void *p) {
      return p ? new(p) ::TEveSceneList[nElements] : new ::TEveSceneList[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveSceneList(void *p) {
      delete ((::TEveSceneList*)p);
   }
   static void deleteArray_TEveSceneList(void *p) {
      delete [] ((::TEveSceneList*)p);
   }
   static void destruct_TEveSceneList(void *p) {
      typedef ::TEveSceneList current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveSceneList

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveSceneInfo(void *p) {
      delete ((::TEveSceneInfo*)p);
   }
   static void deleteArray_TEveSceneInfo(void *p) {
      delete [] ((::TEveSceneInfo*)p);
   }
   static void destruct_TEveSceneInfo(void *p) {
      typedef ::TEveSceneInfo current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveSceneInfo

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveViewer(void *p) {
      return  p ? new(p) ::TEveViewer : new ::TEveViewer;
   }
   static void *newArray_TEveViewer(Long_t nElements, void *p) {
      return p ? new(p) ::TEveViewer[nElements] : new ::TEveViewer[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveViewer(void *p) {
      delete ((::TEveViewer*)p);
   }
   static void deleteArray_TEveViewer(void *p) {
      delete [] ((::TEveViewer*)p);
   }
   static void destruct_TEveViewer(void *p) {
      typedef ::TEveViewer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveViewer

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveViewerList(void *p) {
      return  p ? new(p) ::TEveViewerList : new ::TEveViewerList;
   }
   static void *newArray_TEveViewerList(Long_t nElements, void *p) {
      return p ? new(p) ::TEveViewerList[nElements] : new ::TEveViewerList[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveViewerList(void *p) {
      delete ((::TEveViewerList*)p);
   }
   static void deleteArray_TEveViewerList(void *p) {
      delete [] ((::TEveViewerList*)p);
   }
   static void destruct_TEveViewerList(void *p) {
      typedef ::TEveViewerList current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveViewerList

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveViewerListEditor(void *p) {
      return  p ? new(p) ::TEveViewerListEditor : new ::TEveViewerListEditor;
   }
   static void *newArray_TEveViewerListEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveViewerListEditor[nElements] : new ::TEveViewerListEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveViewerListEditor(void *p) {
      delete ((::TEveViewerListEditor*)p);
   }
   static void deleteArray_TEveViewerListEditor(void *p) {
      delete [] ((::TEveViewerListEditor*)p);
   }
   static void destruct_TEveViewerListEditor(void *p) {
      typedef ::TEveViewerListEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveViewerListEditor

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvePad(void *p) {
      return  p ? new(p) ::TEvePad : new ::TEvePad;
   }
   static void *newArray_TEvePad(Long_t nElements, void *p) {
      return p ? new(p) ::TEvePad[nElements] : new ::TEvePad[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvePad(void *p) {
      delete ((::TEvePad*)p);
   }
   static void deleteArray_TEvePad(void *p) {
      delete [] ((::TEvePad*)p);
   }
   static void destruct_TEvePad(void *p) {
      typedef ::TEvePad current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvePad

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveListTreeItem(void *p) {
      delete ((::TEveListTreeItem*)p);
   }
   static void deleteArray_TEveListTreeItem(void *p) {
      delete [] ((::TEveListTreeItem*)p);
   }
   static void destruct_TEveListTreeItem(void *p) {
      typedef ::TEveListTreeItem current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveListTreeItem

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

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

//______________________________________________________________________________
void TEveGListTreeEditorFrame::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveGListTreeEditorFrame.
      TClass *R__cl = ::TEveGListTreeEditorFrame::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(), "*fLTFrame", &fLTFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLTCanvas", &fLTCanvas);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListTree", &fListTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplitter", &fSplitter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditor", &fEditor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCtxMenu", &fCtxMenu);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSignalsConnected", &fSignalsConnected);
      TGMainFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveGListTreeEditorFrame(void *p) {
      return  p ? new(p) ::TEveGListTreeEditorFrame : new ::TEveGListTreeEditorFrame;
   }
   static void *newArray_TEveGListTreeEditorFrame(Long_t nElements, void *p) {
      return p ? new(p) ::TEveGListTreeEditorFrame[nElements] : new ::TEveGListTreeEditorFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveGListTreeEditorFrame(void *p) {
      delete ((::TEveGListTreeEditorFrame*)p);
   }
   static void deleteArray_TEveGListTreeEditorFrame(void *p) {
      delete [] ((::TEveGListTreeEditorFrame*)p);
   }
   static void destruct_TEveGListTreeEditorFrame(void *p) {
      typedef ::TEveGListTreeEditorFrame current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGListTreeEditorFrame

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveBrowser(void *p) {
      delete ((::TEveBrowser*)p);
   }
   static void deleteArray_TEveBrowser(void *p) {
      delete [] ((::TEveBrowser*)p);
   }
   static void destruct_TEveBrowser(void *p) {
      typedef ::TEveBrowser current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveBrowser

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

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

//______________________________________________________________________________
void TEveCompositeFrame::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveCompositeFrame.
      TClass *R__cl = ::TEveCompositeFrame::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTopFrame", &fTopFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToggleBar", &fToggleBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleBar", &fTitleBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIconBar", &fIconBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEveWindowLH", &fEveWindowLH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMiniBar", &fMiniBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEveParent", &fEveParent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEveWindow", &fEveWindow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowInSync", &fShowInSync);
      TGCompositeFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveCompositeFrame(void *p) {
      delete ((::TEveCompositeFrame*)p);
   }
   static void deleteArray_TEveCompositeFrame(void *p) {
      delete [] ((::TEveCompositeFrame*)p);
   }
   static void destruct_TEveCompositeFrame(void *p) {
      typedef ::TEveCompositeFrame current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCompositeFrame

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveCompositeFrameInMainFrame(void *p) {
      delete ((::TEveCompositeFrameInMainFrame*)p);
   }
   static void deleteArray_TEveCompositeFrameInMainFrame(void *p) {
      delete [] ((::TEveCompositeFrameInMainFrame*)p);
   }
   static void destruct_TEveCompositeFrameInMainFrame(void *p) {
      typedef ::TEveCompositeFrameInMainFrame current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCompositeFrameInMainFrame

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveCompositeFrameInPack(void *p) {
      delete ((::TEveCompositeFrameInPack*)p);
   }
   static void deleteArray_TEveCompositeFrameInPack(void *p) {
      delete [] ((::TEveCompositeFrameInPack*)p);
   }
   static void destruct_TEveCompositeFrameInPack(void *p) {
      typedef ::TEveCompositeFrameInPack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCompositeFrameInPack

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveCompositeFrameInTab(void *p) {
      delete ((::TEveCompositeFrameInTab*)p);
   }
   static void deleteArray_TEveCompositeFrameInTab(void *p) {
      delete [] ((::TEveCompositeFrameInTab*)p);
   }
   static void destruct_TEveCompositeFrameInTab(void *p) {
      typedef ::TEveCompositeFrameInTab current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCompositeFrameInTab

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveWindow(void *p) {
      delete ((::TEveWindow*)p);
   }
   static void deleteArray_TEveWindow(void *p) {
      delete [] ((::TEveWindow*)p);
   }
   static void destruct_TEveWindow(void *p) {
      typedef ::TEveWindow current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveWindow

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveWindowEditor(void *p) {
      return  p ? new(p) ::TEveWindowEditor : new ::TEveWindowEditor;
   }
   static void *newArray_TEveWindowEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveWindowEditor[nElements] : new ::TEveWindowEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveWindowEditor(void *p) {
      delete ((::TEveWindowEditor*)p);
   }
   static void deleteArray_TEveWindowEditor(void *p) {
      delete [] ((::TEveWindowEditor*)p);
   }
   static void destruct_TEveWindowEditor(void *p) {
      typedef ::TEveWindowEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveWindowEditor

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveWindowSlot(void *p) {
      return  p ? new(p) ::TEveWindowSlot : new ::TEveWindowSlot;
   }
   static void *newArray_TEveWindowSlot(Long_t nElements, void *p) {
      return p ? new(p) ::TEveWindowSlot[nElements] : new ::TEveWindowSlot[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveWindowSlot(void *p) {
      delete ((::TEveWindowSlot*)p);
   }
   static void deleteArray_TEveWindowSlot(void *p) {
      delete [] ((::TEveWindowSlot*)p);
   }
   static void destruct_TEveWindowSlot(void *p) {
      typedef ::TEveWindowSlot current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveWindowSlot

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveWindowFrame(void *p) {
      delete ((::TEveWindowFrame*)p);
   }
   static void deleteArray_TEveWindowFrame(void *p) {
      delete [] ((::TEveWindowFrame*)p);
   }
   static void destruct_TEveWindowFrame(void *p) {
      typedef ::TEveWindowFrame current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveWindowFrame

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveWindowPack(void *p) {
      delete ((::TEveWindowPack*)p);
   }
   static void deleteArray_TEveWindowPack(void *p) {
      delete [] ((::TEveWindowPack*)p);
   }
   static void destruct_TEveWindowPack(void *p) {
      typedef ::TEveWindowPack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveWindowPack

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveWindowTab(void *p) {
      delete ((::TEveWindowTab*)p);
   }
   static void deleteArray_TEveWindowTab(void *p) {
      delete [] ((::TEveWindowTab*)p);
   }
   static void destruct_TEveWindowTab(void *p) {
      typedef ::TEveWindowTab current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveWindowTab

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveWindowManager(void *p) {
      return  p ? new(p) ::TEveWindowManager : new ::TEveWindowManager;
   }
   static void *newArray_TEveWindowManager(Long_t nElements, void *p) {
      return p ? new(p) ::TEveWindowManager[nElements] : new ::TEveWindowManager[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveWindowManager(void *p) {
      delete ((::TEveWindowManager*)p);
   }
   static void deleteArray_TEveWindowManager(void *p) {
      delete [] ((::TEveWindowManager*)p);
   }
   static void destruct_TEveWindowManager(void *p) {
      typedef ::TEveWindowManager current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveWindowManager

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveGedEditor(void *p) {
      return  p ? new(p) ::TEveGedEditor : new ::TEveGedEditor;
   }
   static void *newArray_TEveGedEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveGedEditor[nElements] : new ::TEveGedEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveGedEditor(void *p) {
      delete ((::TEveGedEditor*)p);
   }
   static void deleteArray_TEveGedEditor(void *p) {
      delete [] ((::TEveGedEditor*)p);
   }
   static void destruct_TEveGedEditor(void *p) {
      typedef ::TEveGedEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGedEditor

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveGedNameFrame(void *p) {
      return  p ? new(p) ::TEveGedNameFrame : new ::TEveGedNameFrame;
   }
   static void *newArray_TEveGedNameFrame(Long_t nElements, void *p) {
      return p ? new(p) ::TEveGedNameFrame[nElements] : new ::TEveGedNameFrame[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveGedNameFrame(void *p) {
      delete ((::TEveGedNameFrame*)p);
   }
   static void deleteArray_TEveGedNameFrame(void *p) {
      delete [] ((::TEveGedNameFrame*)p);
   }
   static void destruct_TEveGedNameFrame(void *p) {
      typedef ::TEveGedNameFrame current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGedNameFrame

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveGedNameTextButton(void *p) {
      delete ((::TEveGedNameTextButton*)p);
   }
   static void deleteArray_TEveGedNameTextButton(void *p) {
      delete [] ((::TEveGedNameTextButton*)p);
   }
   static void destruct_TEveGedNameTextButton(void *p) {
      typedef ::TEveGedNameTextButton current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGedNameTextButton

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveMacro(void *p) {
      return  p ? new(p) ::TEveMacro : new ::TEveMacro;
   }
   static void *newArray_TEveMacro(Long_t nElements, void *p) {
      return p ? new(p) ::TEveMacro[nElements] : new ::TEveMacro[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveMacro(void *p) {
      delete ((::TEveMacro*)p);
   }
   static void deleteArray_TEveMacro(void *p) {
      delete [] ((::TEveMacro*)p);
   }
   static void destruct_TEveMacro(void *p) {
      typedef ::TEveMacro current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveMacro

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

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

//______________________________________________________________________________
void TEveGValuatorBase::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveGValuatorBase.
      TClass *R__cl = ::TEveGValuatorBase::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelWidth", &fLabelWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlignRight", &fAlignRight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowSlider", &fShowSlider);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNELength", &fNELength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNEHeight", &fNEHeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabel", &fLabel);
      TGCompositeFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveGValuatorBase(void *p) {
      delete ((::TEveGValuatorBase*)p);
   }
   static void deleteArray_TEveGValuatorBase(void *p) {
      delete [] ((::TEveGValuatorBase*)p);
   }
   static void destruct_TEveGValuatorBase(void *p) {
      typedef ::TEveGValuatorBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGValuatorBase

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

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

//______________________________________________________________________________
void TEveGValuator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveGValuator.
      TClass *R__cl = ::TEveGValuator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValue", &fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMin", &fMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMax", &fMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSliderNewLine", &fSliderNewLine);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSliderDivs", &fSliderDivs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEntry", &fEntry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSlider", &fSlider);
      TEveGValuatorBase::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveGValuator(void *p) {
      delete ((::TEveGValuator*)p);
   }
   static void deleteArray_TEveGValuator(void *p) {
      delete [] ((::TEveGValuator*)p);
   }
   static void destruct_TEveGValuator(void *p) {
      typedef ::TEveGValuator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGValuator

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveGDoubleValuator(void *p) {
      delete ((::TEveGDoubleValuator*)p);
   }
   static void deleteArray_TEveGDoubleValuator(void *p) {
      delete [] ((::TEveGDoubleValuator*)p);
   }
   static void destruct_TEveGDoubleValuator(void *p) {
      typedef ::TEveGDoubleValuator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGDoubleValuator

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

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

//______________________________________________________________________________
void TEveGTriVecValuator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveGTriVecValuator.
      TClass *R__cl = ::TEveGTriVecValuator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVal[3]", &fVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelWidth", &fLabelWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNELength", &fNELength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNEHeight", &fNEHeight);
      TGCompositeFrame::ShowMembers(R__insp);
      TGWidget::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveGTriVecValuator(void *p) {
      delete ((::TEveGTriVecValuator*)p);
   }
   static void deleteArray_TEveGTriVecValuator(void *p) {
      delete [] ((::TEveGTriVecValuator*)p);
   }
   static void destruct_TEveGTriVecValuator(void *p) {
      typedef ::TEveGTriVecValuator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGTriVecValuator

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveProjectable(void *p) {
      delete ((::TEveProjectable*)p);
   }
   static void deleteArray_TEveProjectable(void *p) {
      delete [] ((::TEveProjectable*)p);
   }
   static void destruct_TEveProjectable(void *p) {
      typedef ::TEveProjectable current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveProjectable

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveProjected(void *p) {
      delete ((::TEveProjected*)p);
   }
   static void deleteArray_TEveProjected(void *p) {
      delete [] ((::TEveProjected*)p);
   }
   static void destruct_TEveProjected(void *p) {
      typedef ::TEveProjected current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveProjected

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

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

//______________________________________________________________________________
void TEveProjection::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveProjection.
      TClass *R__cl = ::TEveProjection::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(), "fGeoMode", &fGeoMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &fName);
      R__insp.InspectMember(fName, "fName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCenter", &fCenter);
      R__insp.InspectMember(fCenter, "fCenter.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZeroPosVal", &fZeroPosVal);
      R__insp.InspectMember(fZeroPosVal, "fZeroPosVal.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUsePreScale", &fUsePreScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPreScales[3]", fPreScales);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDistortion", &fDistortion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFixR", &fFixR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFixZ", &fFixZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPastFixRFac", &fPastFixRFac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPastFixZFac", &fPastFixZFac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaleR", &fScaleR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaleZ", &fScaleZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPastFixRScale", &fPastFixRScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPastFixZScale", &fPastFixZScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxTrackStep", &fMaxTrackStep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowLimit", &fLowLimit);
      R__insp.InspectMember(fLowLimit, "fLowLimit.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpLimit", &fUpLimit);
      R__insp.InspectMember(fUpLimit, "fUpLimit.");
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveProjection(void *p) {
      delete ((::TEveProjection*)p);
   }
   static void deleteArray_TEveProjection(void *p) {
      delete [] ((::TEveProjection*)p);
   }
   static void destruct_TEveProjection(void *p) {
      typedef ::TEveProjection current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveProjection

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveProjectioncLcLPreScaleEntry_t(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveProjection::PreScaleEntry_t : new ::TEveProjection::PreScaleEntry_t;
   }
   static void *newArray_TEveProjectioncLcLPreScaleEntry_t(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveProjection::PreScaleEntry_t[nElements] : new ::TEveProjection::PreScaleEntry_t[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveProjectioncLcLPreScaleEntry_t(void *p) {
      delete ((::TEveProjection::PreScaleEntry_t*)p);
   }
   static void deleteArray_TEveProjectioncLcLPreScaleEntry_t(void *p) {
      delete [] ((::TEveProjection::PreScaleEntry_t*)p);
   }
   static void destruct_TEveProjectioncLcLPreScaleEntry_t(void *p) {
      typedef ::TEveProjection::PreScaleEntry_t current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveProjection::PreScaleEntry_t

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator : new ::vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator;
   }
   static void *newArray_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator[nElements] : new ::vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator(void *p) {
      delete ((::vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*)p);
   }
   static void deleteArray_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator(void *p) {
      delete [] ((::vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*)p);
   }
   static void destruct_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator(void *p) {
      typedef ::vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveRhoZProjection(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveRhoZProjection : new ::TEveRhoZProjection;
   }
   static void *newArray_TEveRhoZProjection(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveRhoZProjection[nElements] : new ::TEveRhoZProjection[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveRhoZProjection(void *p) {
      delete ((::TEveRhoZProjection*)p);
   }
   static void deleteArray_TEveRhoZProjection(void *p) {
      delete [] ((::TEveRhoZProjection*)p);
   }
   static void destruct_TEveRhoZProjection(void *p) {
      typedef ::TEveRhoZProjection current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveRhoZProjection

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveRPhiProjection(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveRPhiProjection : new ::TEveRPhiProjection;
   }
   static void *newArray_TEveRPhiProjection(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveRPhiProjection[nElements] : new ::TEveRPhiProjection[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveRPhiProjection(void *p) {
      delete ((::TEveRPhiProjection*)p);
   }
   static void deleteArray_TEveRPhiProjection(void *p) {
      delete [] ((::TEveRPhiProjection*)p);
   }
   static void destruct_TEveRPhiProjection(void *p) {
      typedef ::TEveRPhiProjection current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveRPhiProjection

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEve3DProjection(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEve3DProjection : new ::TEve3DProjection;
   }
   static void *newArray_TEve3DProjection(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEve3DProjection[nElements] : new ::TEve3DProjection[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEve3DProjection(void *p) {
      delete ((::TEve3DProjection*)p);
   }
   static void deleteArray_TEve3DProjection(void *p) {
      delete [] ((::TEve3DProjection*)p);
   }
   static void destruct_TEve3DProjection(void *p) {
      typedef ::TEve3DProjection current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEve3DProjection

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

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

//______________________________________________________________________________
void TEveProjectionManager::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveProjectionManager.
      TClass *R__cl = ::TEveProjectionManager::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProjections[4]", &fProjections);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProjection", &fProjection);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCenter", &fCenter);
      R__insp.InspectMember(fCenter, "fCenter.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentDepth", &fCurrentDepth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDependentEls", (void*)&fDependentEls);
      R__insp.InspectMember("TEveElement::List_t", (void*)&fDependentEls, "fDependentEls.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fImportEmpty", &fImportEmpty);
      TEveElementList::ShowMembers(R__insp);
      TAttBBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveProjectionManager(void *p) {
      return  p ? new(p) ::TEveProjectionManager : new ::TEveProjectionManager;
   }
   static void *newArray_TEveProjectionManager(Long_t nElements, void *p) {
      return p ? new(p) ::TEveProjectionManager[nElements] : new ::TEveProjectionManager[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveProjectionManager(void *p) {
      delete ((::TEveProjectionManager*)p);
   }
   static void deleteArray_TEveProjectionManager(void *p) {
      delete [] ((::TEveProjectionManager*)p);
   }
   static void destruct_TEveProjectionManager(void *p) {
      typedef ::TEveProjectionManager current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveProjectionManager

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

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

//______________________________________________________________________________
void TEveProjectionManagerEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveProjectionManagerEditor.
      TClass *R__cl = ::TEveProjectionManagerEditor::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(), "*fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDistortion", &fDistortion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFixR", &fFixR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFixZ", &fFixZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPastFixRFac", &fPastFixRFac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPastFixZFac", &fPastFixZFac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentDepth", &fCurrentDepth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaxTrackStep", &fMaxTrackStep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCenterFrame", &fCenterFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCenterX", &fCenterX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCenterY", &fCenterY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCenterZ", &fCenterZ);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveProjectionManagerEditor(void *p) {
      return  p ? new(p) ::TEveProjectionManagerEditor : new ::TEveProjectionManagerEditor;
   }
   static void *newArray_TEveProjectionManagerEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveProjectionManagerEditor[nElements] : new ::TEveProjectionManagerEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveProjectionManagerEditor(void *p) {
      delete ((::TEveProjectionManagerEditor*)p);
   }
   static void deleteArray_TEveProjectionManagerEditor(void *p) {
      delete [] ((::TEveProjectionManagerEditor*)p);
   }
   static void destruct_TEveProjectionManagerEditor(void *p) {
      typedef ::TEveProjectionManagerEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveProjectionManagerEditor

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

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

//______________________________________________________________________________
void TEveProjectionAxes::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveProjectionAxes.
      TClass *R__cl = ::TEveProjectionAxes::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fManager", &fManager);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseColorSet", &fUseColorSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabMode", &fLabMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxesMode", &fAxesMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawCenter", &fDrawCenter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawOrigin", &fDrawOrigin);
      TEveElement::ShowMembers(R__insp);
      TNamed::ShowMembers(R__insp);
      TAtt3D::ShowMembers(R__insp);
      TAttBBox::ShowMembers(R__insp);
      TAttAxis::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveProjectionAxes(void *p) {
      delete ((::TEveProjectionAxes*)p);
   }
   static void deleteArray_TEveProjectionAxes(void *p) {
      delete [] ((::TEveProjectionAxes*)p);
   }
   static void destruct_TEveProjectionAxes(void *p) {
      typedef ::TEveProjectionAxes current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveProjectionAxes

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

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

//______________________________________________________________________________
void TEveProjectionAxesEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveProjectionAxesEditor.
      TClass *R__cl = ::TEveProjectionAxesEditor::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(), "*fLabMode", &fLabMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxesMode", &fAxesMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCenterFrame", &fCenterFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDrawCenter", &fDrawCenter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDrawOrigin", &fDrawOrigin);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveProjectionAxesEditor(void *p) {
      return  p ? new(p) ::TEveProjectionAxesEditor : new ::TEveProjectionAxesEditor;
   }
   static void *newArray_TEveProjectionAxesEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveProjectionAxesEditor[nElements] : new ::TEveProjectionAxesEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveProjectionAxesEditor(void *p) {
      delete ((::TEveProjectionAxesEditor*)p);
   }
   static void deleteArray_TEveProjectionAxesEditor(void *p) {
      delete [] ((::TEveProjectionAxesEditor*)p);
   }
   static void destruct_TEveProjectionAxesEditor(void *p) {
      typedef ::TEveProjectionAxesEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveProjectionAxesEditor

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveProjectionAxesGL::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveProjectionAxesGL::Class(),this);
   }
}

//______________________________________________________________________________
void TEveProjectionAxesGL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveProjectionAxesGL.
      TClass *R__cl = ::TEveProjectionAxesGL::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(), "*fProjection", &fProjection);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxisPainter", &fAxisPainter);
      R__insp.InspectMember(fAxisPainter, "fAxisPainter.");
      TGLObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveProjectionAxesGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveProjectionAxesGL : new ::TEveProjectionAxesGL;
   }
   static void *newArray_TEveProjectionAxesGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveProjectionAxesGL[nElements] : new ::TEveProjectionAxesGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveProjectionAxesGL(void *p) {
      delete ((::TEveProjectionAxesGL*)p);
   }
   static void deleteArray_TEveProjectionAxesGL(void *p) {
      delete [] ((::TEveProjectionAxesGL*)p);
   }
   static void destruct_TEveProjectionAxesGL(void *p) {
      typedef ::TEveProjectionAxesGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveProjectionAxesGL

//______________________________________________________________________________
void TEveParamList::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveParamList.

   TEveElement::Streamer(R__b);
   TNamed::Streamer(R__b);
   TQObject::Streamer(R__b);
}

//______________________________________________________________________________
void TEveParamList::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveParamList.
      TClass *R__cl = ::TEveParamList::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColor", &fColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFloatParameters", (void*)&fFloatParameters);
      R__insp.InspectMember("TEveParamList::FloatConfigVec_t", (void*)&fFloatParameters, "fFloatParameters.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIntParameters", (void*)&fIntParameters);
      R__insp.InspectMember("TEveParamList::IntConfigVec_t", (void*)&fIntParameters, "fIntParameters.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoolParameters", (void*)&fBoolParameters);
      R__insp.InspectMember("TEveParamList::BoolConfigVec_t", (void*)&fBoolParameters, "fBoolParameters.", false);
      TEveElement::ShowMembers(R__insp);
      TNamed::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveParamList(void *p) {
      return  p ? new(p) ::TEveParamList : new ::TEveParamList;
   }
   static void *newArray_TEveParamList(Long_t nElements, void *p) {
      return p ? new(p) ::TEveParamList[nElements] : new ::TEveParamList[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveParamList(void *p) {
      delete ((::TEveParamList*)p);
   }
   static void deleteArray_TEveParamList(void *p) {
      delete [] ((::TEveParamList*)p);
   }
   static void destruct_TEveParamList(void *p) {
      typedef ::TEveParamList current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TEveParamList(TBuffer &buf, void *obj) {
      ((::TEveParamList*)obj)->::TEveParamList::Streamer(buf);
   }
} // end of namespace ROOT for class ::TEveParamList

//______________________________________________________________________________
namespace ROOT {
   void TEveParamListcLcLFloatConfig_t_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TEveParamList::FloatConfig_t.
      typedef ::ROOT::Shadow::TEveParamList::FloatConfig_t ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TEveParamList::FloatConfig_t*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValue", &sobj->fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMin", &sobj->fMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMax", &sobj->fMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &sobj->fName);
      R__insp.InspectMember(sobj->fName, "fName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelector", &sobj->fSelector);
   }

}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveParamListcLcLFloatConfig_t(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveParamList::FloatConfig_t : new ::TEveParamList::FloatConfig_t;
   }
   static void *newArray_TEveParamListcLcLFloatConfig_t(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveParamList::FloatConfig_t[nElements] : new ::TEveParamList::FloatConfig_t[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveParamListcLcLFloatConfig_t(void *p) {
      delete ((::TEveParamList::FloatConfig_t*)p);
   }
   static void deleteArray_TEveParamListcLcLFloatConfig_t(void *p) {
      delete [] ((::TEveParamList::FloatConfig_t*)p);
   }
   static void destruct_TEveParamListcLcLFloatConfig_t(void *p) {
      typedef ::TEveParamList::FloatConfig_t current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveParamList::FloatConfig_t

//______________________________________________________________________________
namespace ROOT {
   void TEveParamListcLcLIntConfig_t_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TEveParamList::IntConfig_t.
      typedef ::ROOT::Shadow::TEveParamList::IntConfig_t ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TEveParamList::IntConfig_t*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValue", &sobj->fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMin", &sobj->fMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMax", &sobj->fMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &sobj->fName);
      R__insp.InspectMember(sobj->fName, "fName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelector", &sobj->fSelector);
   }

}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveParamListcLcLIntConfig_t(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveParamList::IntConfig_t : new ::TEveParamList::IntConfig_t;
   }
   static void *newArray_TEveParamListcLcLIntConfig_t(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveParamList::IntConfig_t[nElements] : new ::TEveParamList::IntConfig_t[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveParamListcLcLIntConfig_t(void *p) {
      delete ((::TEveParamList::IntConfig_t*)p);
   }
   static void deleteArray_TEveParamListcLcLIntConfig_t(void *p) {
      delete [] ((::TEveParamList::IntConfig_t*)p);
   }
   static void destruct_TEveParamListcLcLIntConfig_t(void *p) {
      typedef ::TEveParamList::IntConfig_t current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveParamList::IntConfig_t

//______________________________________________________________________________
namespace ROOT {
   void TEveParamListcLcLBoolConfig_t_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TEveParamList::BoolConfig_t.
      typedef ::ROOT::Shadow::TEveParamList::BoolConfig_t ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TEveParamList::BoolConfig_t*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValue", &sobj->fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &sobj->fName);
      R__insp.InspectMember(sobj->fName, "fName.");
   }

}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveParamListcLcLBoolConfig_t(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveParamList::BoolConfig_t : new ::TEveParamList::BoolConfig_t;
   }
   static void *newArray_TEveParamListcLcLBoolConfig_t(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveParamList::BoolConfig_t[nElements] : new ::TEveParamList::BoolConfig_t[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveParamListcLcLBoolConfig_t(void *p) {
      delete ((::TEveParamList::BoolConfig_t*)p);
   }
   static void deleteArray_TEveParamListcLcLBoolConfig_t(void *p) {
      delete [] ((::TEveParamList::BoolConfig_t*)p);
   }
   static void destruct_TEveParamListcLcLBoolConfig_t(void *p) {
      typedef ::TEveParamList::BoolConfig_t current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveParamList::BoolConfig_t

//______________________________________________________________________________
void TEveParamListEditor::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveParamListEditor.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveParamListEditor::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveParamListEditor::Class(),this);
   }
}

//______________________________________________________________________________
void TEveParamListEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveParamListEditor.
      TClass *R__cl = ::TEveParamListEditor::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(), "*fParamFrame", &fParamFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIntParameters", (void*)&fIntParameters);
      R__insp.InspectMember("vector<TGNumberEntry*>", (void*)&fIntParameters, "fIntParameters.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFloatParameters", (void*)&fFloatParameters);
      R__insp.InspectMember("vector<TGNumberEntry*>", (void*)&fFloatParameters, "fFloatParameters.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoolParameters", (void*)&fBoolParameters);
      R__insp.InspectMember("vector<TGCheckButton*>", (void*)&fBoolParameters, "fBoolParameters.", false);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveParamListEditor(void *p) {
      return  p ? new(p) ::TEveParamListEditor : new ::TEveParamListEditor;
   }
   static void *newArray_TEveParamListEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveParamListEditor[nElements] : new ::TEveParamListEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveParamListEditor(void *p) {
      delete ((::TEveParamListEditor*)p);
   }
   static void deleteArray_TEveParamListEditor(void *p) {
      delete [] ((::TEveParamListEditor*)p);
   }
   static void destruct_TEveParamListEditor(void *p) {
      typedef ::TEveParamListEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveParamListEditor

namespace ROOT {
   void listlETEveElementmUgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void listlETEveElementmUgR_Dictionary();
   static void *new_listlETEveElementmUgR(void *p = 0);
   static void *newArray_listlETEveElementmUgR(Long_t size, void *p);
   static void delete_listlETEveElementmUgR(void *p);
   static void deleteArray_listlETEveElementmUgR(void *p);
   static void destruct_listlETEveElementmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const list<TEveElement*>*)
   {
      list<TEveElement*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(list<TEveElement*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("list<TEveElement*>", -2, "prec_stl/list", 44,
                  typeid(list<TEveElement*>), DefineBehavior(ptr, ptr),
                  0, &listlETEveElementmUgR_Dictionary, isa_proxy, 0,
                  sizeof(list<TEveElement*>) );
      instance.SetNew(&new_listlETEveElementmUgR);
      instance.SetNewArray(&newArray_listlETEveElementmUgR);
      instance.SetDelete(&delete_listlETEveElementmUgR);
      instance.SetDeleteArray(&deleteArray_listlETEveElementmUgR);
      instance.SetDestructor(&destruct_listlETEveElementmUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< list<TEveElement*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const list<TEveElement*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void listlETEveElementmUgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const list<TEveElement*>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_listlETEveElementmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) list<TEveElement*> : new list<TEveElement*>;
   }
   static void *newArray_listlETEveElementmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) list<TEveElement*>[nElements] : new list<TEveElement*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_listlETEveElementmUgR(void *p) {
      delete ((list<TEveElement*>*)p);
   }
   static void deleteArray_listlETEveElementmUgR(void *p) {
      delete [] ((list<TEveElement*>*)p);
   }
   static void destruct_listlETEveElementmUgR(void *p) {
      typedef list<TEveElement*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class list<TEveElement*>

namespace ROOT {
   void setlETEveElementmUgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void setlETEveElementmUgR_Dictionary();
   static void *new_setlETEveElementmUgR(void *p = 0);
   static void *newArray_setlETEveElementmUgR(Long_t size, void *p);
   static void delete_setlETEveElementmUgR(void *p);
   static void deleteArray_setlETEveElementmUgR(void *p);
   static void destruct_setlETEveElementmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const set<TEveElement*>*)
   {
      set<TEveElement*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(set<TEveElement*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("set<TEveElement*>", -2, "prec_stl/set", 49,
                  typeid(set<TEveElement*>), DefineBehavior(ptr, ptr),
                  0, &setlETEveElementmUgR_Dictionary, isa_proxy, 0,
                  sizeof(set<TEveElement*>) );
      instance.SetNew(&new_setlETEveElementmUgR);
      instance.SetNewArray(&newArray_setlETEveElementmUgR);
      instance.SetDelete(&delete_setlETEveElementmUgR);
      instance.SetDeleteArray(&deleteArray_setlETEveElementmUgR);
      instance.SetDestructor(&destruct_setlETEveElementmUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Insert< set<TEveElement*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const set<TEveElement*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void setlETEveElementmUgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const set<TEveElement*>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_setlETEveElementmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) set<TEveElement*> : new set<TEveElement*>;
   }
   static void *newArray_setlETEveElementmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) set<TEveElement*>[nElements] : new set<TEveElement*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_setlETEveElementmUgR(void *p) {
      delete ((set<TEveElement*>*)p);
   }
   static void deleteArray_setlETEveElementmUgR(void *p) {
      delete [] ((set<TEveElement*>*)p);
   }
   static void destruct_setlETEveElementmUgR(void *p) {
      typedef set<TEveElement*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class set<TEveElement*>

namespace ROOT {
   void vectorlETArrayCmUgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlETArrayCmUgR_Dictionary();
   static void *new_vectorlETArrayCmUgR(void *p = 0);
   static void *newArray_vectorlETArrayCmUgR(Long_t size, void *p);
   static void delete_vectorlETArrayCmUgR(void *p);
   static void deleteArray_vectorlETArrayCmUgR(void *p);
   static void destruct_vectorlETArrayCmUgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<TArrayC*>*)
   {
      vector<TArrayC*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<TArrayC*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<TArrayC*>", -2, "prec_stl/vector", 49,
                  typeid(vector<TArrayC*>), DefineBehavior(ptr, ptr),
                  0, &vectorlETArrayCmUgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<TArrayC*>) );
      instance.SetNew(&new_vectorlETArrayCmUgR);
      instance.SetNewArray(&newArray_vectorlETArrayCmUgR);
      instance.SetDelete(&delete_vectorlETArrayCmUgR);
      instance.SetDeleteArray(&deleteArray_vectorlETArrayCmUgR);
      instance.SetDestructor(&destruct_vectorlETArrayCmUgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<TArrayC*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<TArrayC*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlETArrayCmUgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<TArrayC*>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlETArrayCmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TArrayC*> : new vector<TArrayC*>;
   }
   static void *newArray_vectorlETArrayCmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TArrayC*>[nElements] : new vector<TArrayC*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlETArrayCmUgR(void *p) {
      delete ((vector<TArrayC*>*)p);
   }
   static void deleteArray_vectorlETArrayCmUgR(void *p) {
      delete [] ((vector<TArrayC*>*)p);
   }
   static void destruct_vectorlETArrayCmUgR(void *p) {
      typedef vector<TArrayC*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<TArrayC*>

namespace ROOT {
   void vectorlETEveProjectioncLcLPreScaleEntry_tgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlETEveProjectioncLcLPreScaleEntry_tgR_Dictionary();
   static void *new_vectorlETEveProjectioncLcLPreScaleEntry_tgR(void *p = 0);
   static void *newArray_vectorlETEveProjectioncLcLPreScaleEntry_tgR(Long_t size, void *p);
   static void delete_vectorlETEveProjectioncLcLPreScaleEntry_tgR(void *p);
   static void deleteArray_vectorlETEveProjectioncLcLPreScaleEntry_tgR(void *p);
   static void destruct_vectorlETEveProjectioncLcLPreScaleEntry_tgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<TEveProjection::PreScaleEntry_t>*)
   {
      vector<TEveProjection::PreScaleEntry_t> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<TEveProjection::PreScaleEntry_t>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<TEveProjection::PreScaleEntry_t>", -2, "prec_stl/vector", 49,
                  typeid(vector<TEveProjection::PreScaleEntry_t>), DefineBehavior(ptr, ptr),
                  0, &vectorlETEveProjectioncLcLPreScaleEntry_tgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<TEveProjection::PreScaleEntry_t>) );
      instance.SetNew(&new_vectorlETEveProjectioncLcLPreScaleEntry_tgR);
      instance.SetNewArray(&newArray_vectorlETEveProjectioncLcLPreScaleEntry_tgR);
      instance.SetDelete(&delete_vectorlETEveProjectioncLcLPreScaleEntry_tgR);
      instance.SetDeleteArray(&deleteArray_vectorlETEveProjectioncLcLPreScaleEntry_tgR);
      instance.SetDestructor(&destruct_vectorlETEveProjectioncLcLPreScaleEntry_tgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<TEveProjection::PreScaleEntry_t> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<TEveProjection::PreScaleEntry_t>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlETEveProjectioncLcLPreScaleEntry_tgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<TEveProjection::PreScaleEntry_t>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlETEveProjectioncLcLPreScaleEntry_tgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TEveProjection::PreScaleEntry_t> : new vector<TEveProjection::PreScaleEntry_t>;
   }
   static void *newArray_vectorlETEveProjectioncLcLPreScaleEntry_tgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TEveProjection::PreScaleEntry_t>[nElements] : new vector<TEveProjection::PreScaleEntry_t>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlETEveProjectioncLcLPreScaleEntry_tgR(void *p) {
      delete ((vector<TEveProjection::PreScaleEntry_t>*)p);
   }
   static void deleteArray_vectorlETEveProjectioncLcLPreScaleEntry_tgR(void *p) {
      delete [] ((vector<TEveProjection::PreScaleEntry_t>*)p);
   }
   static void destruct_vectorlETEveProjectioncLcLPreScaleEntry_tgR(void *p) {
      typedef vector<TEveProjection::PreScaleEntry_t> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<TEveProjection::PreScaleEntry_t>

namespace ROOT {
   void vectorlETStringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlETStringgR_Dictionary();
   static void *new_vectorlETStringgR(void *p = 0);
   static void *newArray_vectorlETStringgR(Long_t size, void *p);
   static void delete_vectorlETStringgR(void *p);
   static void deleteArray_vectorlETStringgR(void *p);
   static void destruct_vectorlETStringgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<TString>*)
   {
      vector<TString> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<TString>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<TString>", -2, "prec_stl/vector", 49,
                  typeid(vector<TString>), DefineBehavior(ptr, ptr),
                  0, &vectorlETStringgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<TString>) );
      instance.SetNew(&new_vectorlETStringgR);
      instance.SetNewArray(&newArray_vectorlETStringgR);
      instance.SetDelete(&delete_vectorlETStringgR);
      instance.SetDeleteArray(&deleteArray_vectorlETStringgR);
      instance.SetDestructor(&destruct_vectorlETStringgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<TString> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<TString>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlETStringgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<TString>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlETStringgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TString> : new vector<TString>;
   }
   static void *newArray_vectorlETStringgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TString>[nElements] : new vector<TString>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlETStringgR(void *p) {
      delete ((vector<TString>*)p);
   }
   static void deleteArray_vectorlETStringgR(void *p) {
      delete [] ((vector<TString>*)p);
   }
   static void destruct_vectorlETStringgR(void *p) {
      typedef vector<TString> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<TString>

/********************************************************
* graf3d/eve/src/G__Eve1.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__Eve1();

extern "C" void G__set_cpp_environmentG__Eve1() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TEveBrowser.h");
  G__add_compiledheader("TEveChunkManager.h");
  G__add_compiledheader("TEveCompound.h");
  G__add_compiledheader("TEveElementEditor.h");
  G__add_compiledheader("TEveElement.h");
  G__add_compiledheader("TEveEventManager.h");
  G__add_compiledheader("TEveGValuators.h");
  G__add_compiledheader("TEveGedEditor.h");
  G__add_compiledheader("TEveMacro.h");
  G__add_compiledheader("TEveManager.h");
  G__add_compiledheader("TEvePad.h");
  G__add_compiledheader("TEveParamList.h");
  G__add_compiledheader("TEveProjectionAxesEditor.h");
  G__add_compiledheader("TEveProjectionAxesGL.h");
  G__add_compiledheader("TEveProjectionAxes.h");
  G__add_compiledheader("TEveProjectionBases.h");
  G__add_compiledheader("TEveProjectionManagerEditor.h");
  G__add_compiledheader("TEveProjectionManager.h");
  G__add_compiledheader("TEveProjections.h");
  G__add_compiledheader("TEveScene.h");
  G__add_compiledheader("TEveSceneInfo.h");
  G__add_compiledheader("TEveSelection.h");
  G__add_compiledheader("TEveTransEditor.h");
  G__add_compiledheader("TEveTrans.h");
  G__add_compiledheader("TEveTreeTools.h");
  G__add_compiledheader("TEveUtil.h");
  G__add_compiledheader("TEveVector.h");
  G__add_compiledheader("TEvePathMark.h");
  G__add_compiledheader("TEveVSD.h");
  G__add_compiledheader("TEveVSDStructs.h");
  G__add_compiledheader("TEveViewer.h");
  G__add_compiledheader("TEveViewerListEditor.h");
  G__add_compiledheader("TEveWindowEditor.h");
  G__add_compiledheader("TEveWindow.h");
  G__add_compiledheader("TEveWindowManager.h");
  G__add_compiledheader("TEveSecondarySelectable.h");
  G__add_compiledheader("/misc/hadessoftware/etch32/install/root-5.28.00b/graf3d/eve/src/SolarisCCDictHack.h");
  G__cpp_reset_tagtableG__Eve1();
}
#include <new>
extern "C" int G__cpp_dllrevG__Eve1() { return(30051515); }

/*********************************************************
* Member function Interface Method
*********************************************************/

/* TEveElement */
static int G__G__Eve1_131_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveElement[n];
     } else {
       p = new((void*) gvp) TEveElement[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveElement;
     } else {
       p = new((void*) gvp) TEveElement;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveElement(*(Color_t*) G__Shortref(&libp->para[0]));
   } else {
     p = new((void*) gvp) TEveElement(*(Color_t*) G__Shortref(&libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveElement(*(TEveElement*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEveElement(*(TEveElement*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveElement*) G__getstructoffset())->CloneElement());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TEveElement*) G__getstructoffset())->CloneElementRecurse((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TEveElement*) G__getstructoffset())->CloneElementRecurse());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TEveElement*) G__getstructoffset())->CloneChildrenRecurse((TEveElement*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TEveElement*) G__getstructoffset())->CloneChildrenRecurse((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TEveElement*) G__getstructoffset())->GetElementName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TEveElement*) G__getstructoffset())->GetElementTitle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TEveElement*) G__getstructoffset())->GetHighlightTooltip();
         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__Eve1_131_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetElementName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetElementTitle((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetElementNameTitle((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__Eve1_131_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->NameTitleChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString& obj = ((const TEveElement*) G__getstructoffset())->GetVizTag();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetVizTag(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveElement*) G__getstructoffset())->GetVizModel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetVizModel((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveElement*) G__getstructoffset())->FindVizModel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TEveElement*) G__getstructoffset())->ApplyVizTag(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TEveElement*) G__getstructoffset())->ApplyVizTag(*(TString*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->PropagateVizParamsToProjecteds();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveElement*) G__getstructoffset())->PropagateVizParamsToElements((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveElement*) G__getstructoffset())->PropagateVizParamsToElements();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->CopyVizParams((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->CopyVizParamsFromDB();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SaveVizParams(*(ostream*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->WriteVizParams(*(ostream*) libp->para[0].ref, *(TString*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->GetMaster());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->GetCompound());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetCompound((TEveCompound*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->AddParent((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->RemoveParent((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveElement*) G__getstructoffset())->CheckReferenceCount(*(TEveException*) libp->para[0].ref);
      G__setnull(result7);
      break;
   case 0:
      ((TEveElement*) G__getstructoffset())->CheckReferenceCount();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->CollectSceneParents(*(TEveElement::List_t*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->CollectSceneParentsFromChildren(*(TEveElement::List_t*) libp->para[0].ref, (TEveElement*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveElement::List_i* pobj;
         TEveElement::List_i xobj = ((TEveElement*) G__getstructoffset())->BeginParents();
         pobj = new TEveElement::List_i(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__Eve1_131_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveElement::List_i* pobj;
         TEveElement::List_i xobj = ((TEveElement*) G__getstructoffset())->EndParents();
         pobj = new TEveElement::List_i(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__Eve1_131_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveElement::List_ci* pobj;
         const TEveElement::List_ci xobj = ((const TEveElement*) G__getstructoffset())->BeginParents();
         pobj = new TEveElement::List_ci(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__Eve1_131_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveElement::List_ci* pobj;
         const TEveElement::List_ci xobj = ((const TEveElement*) G__getstructoffset())->EndParents();
         pobj = new TEveElement::List_ci(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__Eve1_131_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveElement*) G__getstructoffset())->NumParents());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement*) G__getstructoffset())->HasParents());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveElement::List_t& obj = ((const TEveElement*) G__getstructoffset())->RefChildren();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveElement::List_i* pobj;
         TEveElement::List_i xobj = ((TEveElement*) G__getstructoffset())->BeginChildren();
         pobj = new TEveElement::List_i(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__Eve1_131_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveElement::List_i* pobj;
         TEveElement::List_i xobj = ((TEveElement*) G__getstructoffset())->EndChildren();
         pobj = new TEveElement::List_i(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__Eve1_131_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveElement::List_ci* pobj;
         const TEveElement::List_ci xobj = ((const TEveElement*) G__getstructoffset())->BeginChildren();
         pobj = new TEveElement::List_ci(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__Eve1_131_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveElement::List_ci* pobj;
         const TEveElement::List_ci xobj = ((const TEveElement*) G__getstructoffset())->EndChildren();
         pobj = new TEveElement::List_ci(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__Eve1_131_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveElement*) G__getstructoffset())->NumChildren());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement*) G__getstructoffset())->HasChildren());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveElement*) G__getstructoffset())->HasChild((TEveElement*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->FindChild(*(TString*) libp->para[0].ref, (TClass*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->FindChild(*(TString*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->FindChild(*(TPRegexp*) libp->para[0].ref, (TClass*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->FindChild(*(TPRegexp*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TEveElement*) G__getstructoffset())->FindChildren(*(TEveElement::List_t*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TClass*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TEveElement*) G__getstructoffset())->FindChildren(*(TEveElement::List_t*) libp->para[0].ref, *(TString*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TEveElement*) G__getstructoffset())->FindChildren(*(TEveElement::List_t*) libp->para[0].ref, *(TPRegexp*) libp->para[1].ref
, (TClass*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TEveElement*) G__getstructoffset())->FindChildren(*(TEveElement::List_t*) libp->para[0].ref, *(TPRegexp*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveElement*) G__getstructoffset())->FirstChild());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveElement*) G__getstructoffset())->LastChild());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEveElement*) G__getstructoffset())->EnableListElements((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveElement*) G__getstructoffset())->EnableListElements((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveElement*) G__getstructoffset())->EnableListElements();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEveElement*) G__getstructoffset())->DisableListElements((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveElement*) G__getstructoffset())->DisableListElements((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveElement*) G__getstructoffset())->DisableListElements();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement*) G__getstructoffset())->GetDestroyOnZeroRefCnt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetDestroyOnZeroRefCnt((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveElement*) G__getstructoffset())->GetDenyDestroy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->IncDenyDestroy();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->DecDenyDestroy();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveElement*) G__getstructoffset())->GetParentIgnoreCnt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->IncParentIgnoreCnt();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->DecParentIgnoreCnt();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->PadPaint((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->PaintStandard((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveElement*) G__getstructoffset())->GetObject(*(TEveException*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveElement*) G__getstructoffset())->GetEditorObject(*(TEveException*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveElement*) G__getstructoffset())->GetRenderObject(*(TEveException*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->ExpandIntoListTree((TGListTree*) G__int(libp->para[0]), (TGListTreeItem*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->DestroyListSubTree((TGListTree*) G__int(libp->para[0]), (TGListTreeItem*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->AddIntoListTree((TGListTree*) G__int(libp->para[0]), (TGListTreeItem*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->AddIntoListTree((TGListTree*) G__int(libp->para[0]), (TEveElement*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->AddIntoListTrees((TEveElement*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveElement*) G__getstructoffset())->RemoveFromListTree((TGListTree*) G__int(libp->para[0]), (TGListTreeItem*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEveElement*) G__getstructoffset())->RemoveFromListTrees((TEveElement*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveElement::sLTI_i* pobj;
         TEveElement::sLTI_i xobj = ((TEveElement*) G__getstructoffset())->FindItem((TGListTree*) G__int(libp->para[0]));
         pobj = new TEveElement::sLTI_i(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__Eve1_131_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveElement::sLTI_i* pobj;
         TEveElement::sLTI_i xobj = ((TEveElement*) G__getstructoffset())->FindItem((TGListTree*) G__int(libp->para[0]), (TGListTreeItem*) G__int(libp->para[1]));
         pobj = new TEveElement::sLTI_i(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__Eve1_131_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->FindListTreeItem((TGListTree*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->FindListTreeItem((TGListTree*) G__int(libp->para[0]), (TGListTreeItem*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveElement*) G__getstructoffset())->GetNItems());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SpawnEditor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->ExportToCINT((char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveElement*) G__getstructoffset())->DumpSourceObject();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveElement*) G__getstructoffset())->PrintSourceObject();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveElement*) G__getstructoffset())->ExportSourceObjectToCINT((char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveElement*) G__getstructoffset())->AcceptElement((TEveElement*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->AddElement((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->RemoveElement((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->RemoveElementLocal((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->RemoveElements();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->RemoveElementsLocal();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->AnnihilateElements();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->Annihilate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEveElement*) G__getstructoffset())->ProjectChild((TEveElement*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveElement*) G__getstructoffset())->ProjectChild((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveElement*) G__getstructoffset())->ProjectAllChildren((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveElement*) G__getstructoffset())->ProjectAllChildren();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->Destroy();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->DestroyOrWarn();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->DestroyElements();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveElement*) G__getstructoffset())->HandleElementPaste((TEveElement*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEveElement*) G__getstructoffset())->ElementChanged((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveElement*) G__getstructoffset())->ElementChanged((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveElement*) G__getstructoffset())->ElementChanged();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement*) G__getstructoffset())->CanEditElement());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement*) G__getstructoffset())->SingleRnrState());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement*) G__getstructoffset())->GetRnrSelf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement*) G__getstructoffset())->GetRnrChildren());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement*) G__getstructoffset())->GetRnrState());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement*) G__getstructoffset())->GetRnrAnything());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveElement*) G__getstructoffset())->SetRnrSelf((Bool_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveElement*) G__getstructoffset())->SetRnrChildren((Bool_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveElement*) G__getstructoffset())->SetRnrSelfChildren((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveElement*) G__getstructoffset())->SetRnrState((Bool_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->PropagateRnrStateToProjecteds();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement*) G__getstructoffset())->CanEditMainColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetEditMainColor((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 83, (long) ((const TEveElement*) G__getstructoffset())->GetMainColorPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetMainColorPtr((Color_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement*) G__getstructoffset())->HasMainColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TEveElement*) G__getstructoffset())->GetMainColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetMainColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetMainColorPixel((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetMainColorRGB((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__Eve1_131_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetMainColorRGB((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__Eve1_131_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->PropagateMainColorToProjecteds((Color_t) G__int(libp->para[0]), (Color_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement*) G__getstructoffset())->CanEditMainTransparency());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetEditMainTransparency((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((const TEveElement*) G__getstructoffset())->GetMainTransparency());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetMainTransparency((Char_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetMainAlpha((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->PropagateMainTransparencyToProjecteds((Char_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__Eve1_131_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement*) G__getstructoffset())->CanEditMainTrans());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement*) G__getstructoffset())->HasMainTrans());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->PtrMainTrans((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->PtrMainTrans());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveTrans& obj = ((TEveElement*) G__getstructoffset())->RefMainTrans();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveElement*) G__getstructoffset())->InitMainTrans((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveElement*) G__getstructoffset())->InitMainTrans();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->DestroyMainTrans();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetTransMatrix((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetTransMatrix(*(TGeoMatrix*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TRef& obj = ((TEveElement*) G__getstructoffset())->GetSource();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveElement*) G__getstructoffset())->GetSourceObject());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetSourceObject((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_145(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TEveElement*) G__getstructoffset())->GetUserData());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_146(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetUserData((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_147(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement*) G__getstructoffset())->IsPickable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetPickable((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->ForwardSelection());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_150(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->ForwardEdit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_151(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SelectElement((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->IncImpliedSelected();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_153(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->DecImpliedSelected();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_154(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->UnSelected();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_155(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->HighlightElement((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_156(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->IncImpliedHighlighted();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_157(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->DecImpliedHighlighted();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_158(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->UnHighlighted();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_159(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->FillImpliedSelectedSet(*(TEveElement::Set_t*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_160(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 98, (long) ((const TEveElement*) G__getstructoffset())->GetSelectedLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_161(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->RecheckImpliedSelections();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_162(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->SetCSCBits((UChar_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_163(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->ResetCSCBits((UChar_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_164(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement*) G__getstructoffset())->TestCSCBits((UChar_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_165(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->ResetAllCSCBits();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_166(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->CSCImplySelectAllChildren();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_167(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->CSCTakeAnyParentAsMaster();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_168(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->CSCApplyMainColorToAllChildren();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_169(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->CSCApplyMainColorToMatchingChildren();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_170(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->CSCApplyMainTransparencyToAllChildren();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_171(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->CSCApplyMainTransparencyToMatchingChildren();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_172(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->StampColorSelection();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_173(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->StampTransBBox();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_174(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->StampObjProps();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_175(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->StampVisibility();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_176(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->AddStamp((UChar_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_177(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->ClearStamps();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_178(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 98, (long) ((const TEveElement*) G__getstructoffset())->GetChangeBits());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_179(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->GetListTreeIcon((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->GetListTreeIcon());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_180(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveElement*) G__getstructoffset())->GetListTreeCheckBoxIcon());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_181(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->VizDB_Apply((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_182(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->VizDB_Reapply();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_183(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveElement*) G__getstructoffset())->VizDB_UpdateModel((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveElement*) G__getstructoffset())->VizDB_UpdateModel();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_184(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TEveElement*) G__getstructoffset())->VizDB_Insert((const char*) 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:
      ((TEveElement*) G__getstructoffset())->VizDB_Insert((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveElement*) G__getstructoffset())->VizDB_Insert((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_185(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveElement::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_186(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElement::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_187(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveElement::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_188(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveElement::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_189(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveElement*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_190(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_191(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_192(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_193(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElement::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_194(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveElement::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_195(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElement::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_131_0_196(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveElement::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveElement G__TTEveElement;
static int G__G__Eve1_131_0_197(G__value* result7, G__CONST 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[] (TEveElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveElement*) (soff+(sizeof(TEveElement)*i)))->~G__TTEveElement();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveElement*) (soff))->~G__TTEveElement();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveUtil */
static int G__G__Eve1_132_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveUtil::SetupEnvironment();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveUtil::SetupGUI();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TEveUtil::CheckMacro((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveUtil::AssertMacro((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveUtil::Macro((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveUtil::LoadMacro((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      TEveUtil::ColorFromIdx((Color_t) G__int(libp->para[0]), (UChar_t*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      TEveUtil::ColorFromIdx((Color_t) G__int(libp->para[0]), (UChar_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveUtil::ColorFromIdx((Color_t) G__int(libp->para[0]), (UChar_t*) G__int(libp->para[1])
, (Char_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      TEveUtil::ColorFromIdx((Float_t) G__double(libp->para[0]), (Color_t) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Color_t) G__int(libp->para[3])
, (UChar_t*) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      TEveUtil::ColorFromIdx((Float_t) G__double(libp->para[0]), (Color_t) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Color_t) G__int(libp->para[3])
, (UChar_t*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 83, (long) TEveUtil::FindColorVar((TObject*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      TEveUtil::SetColorBrightness((Float_t) G__double(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      TEveUtil::SetColorBrightness((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TEveUtil::IsU1IntervalContainedByMinMax((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])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TEveUtil::IsU1IntervalOverlappingByMinMax((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])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TEveUtil::IsU1IntervalContainedByMeanDelta((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])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TEveUtil::IsU1IntervalOverlappingByMeanDelta((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])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) TEveUtil::GetFraction((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])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveUtil::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveUtil::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveUtil::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveUtil::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveUtil*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveUtil*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveUtil*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveUtil*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveUtil::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveUtil::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveUtil::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_132_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveUtil::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic default constructor
static int G__G__Eve1_132_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveUtil *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveUtil[n];
     } else {
       p = new((void*) gvp) TEveUtil[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveUtil;
     } else {
       p = new((void*) gvp) TEveUtil;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveUtil));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_132_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveUtil* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveUtil(*(TEveUtil*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveUtil));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveUtil G__TTEveUtil;
static int G__G__Eve1_132_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[] (TEveUtil*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveUtil*) (soff+(sizeof(TEveUtil)*i)))->~G__TTEveUtil();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveUtil*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveUtil*) (soff))->~G__TTEveUtil();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_132_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveUtil* dest = (TEveUtil*) G__getstructoffset();
   *dest = *(TEveUtil*) libp->para[0].ref;
   const TEveUtil& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveException */
static int G__G__Eve1_133_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveException* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveException[n];
     } else {
       p = new((void*) gvp) TEveException[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveException;
     } else {
       p = new((void*) gvp) TEveException;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveException));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_133_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveException* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveException(*(TString*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEveException(*(TString*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveException));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_133_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveException* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveException((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveException((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveException));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_133_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveException* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveException(*(string*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEveException(*(string*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveException));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_133_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TEveException*) G__getstructoffset())->what());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_133_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveException::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_133_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveException::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_133_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveException::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_133_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveException::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_133_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveException*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_133_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveException::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_133_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveException::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_133_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveException::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_133_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveException::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_133_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveException* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveException(*(TEveException*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveException));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveException G__TTEveException;
static int G__G__Eve1_133_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[] (TEveException*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveException*) (soff+(sizeof(TEveException)*i)))->~G__TTEveException();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveException*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveException*) (soff))->~G__TTEveException();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_133_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveException* dest = (TEveException*) G__getstructoffset();
   *dest = *(TEveException*) libp->para[0].ref;
   const TEveException& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvePadHolder */
static int G__G__Eve1_134_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePadHolder* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePadHolder(
(Bool_t) G__int(libp->para[0]), (TVirtualPad*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEvePadHolder(
(Bool_t) 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 TEvePadHolder((Bool_t) G__int(libp->para[0]), (TVirtualPad*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEvePadHolder((Bool_t) 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 TEvePadHolder((Bool_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEvePadHolder((Bool_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__Eve1LN_TEvePadHolder));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_134_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvePadHolder::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_134_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePadHolder::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_134_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvePadHolder::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_134_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvePadHolder::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_134_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvePadHolder*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_134_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePadHolder*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_134_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePadHolder*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_134_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePadHolder*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_134_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePadHolder::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_134_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePadHolder::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_134_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePadHolder::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_134_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePadHolder::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvePadHolder G__TTEvePadHolder;
static int G__G__Eve1_134_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[] (TEvePadHolder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvePadHolder*) (soff+(sizeof(TEvePadHolder)*i)))->~G__TTEvePadHolder();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvePadHolder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvePadHolder*) (soff))->~G__TTEvePadHolder();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGeoManagerHolder */
static int G__G__Eve1_135_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGeoManagerHolder* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGeoManagerHolder((TGeoManager*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveGeoManagerHolder((TGeoManager*) 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 TEveGeoManagerHolder((TGeoManager*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveGeoManagerHolder((TGeoManager*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGeoManagerHolder[n];
       } else {
         p = new((void*) gvp) TEveGeoManagerHolder[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGeoManagerHolder;
       } else {
         p = new((void*) gvp) TEveGeoManagerHolder;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveGeoManagerHolder));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_135_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGeoManagerHolder::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_135_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoManagerHolder::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_135_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGeoManagerHolder::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_135_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGeoManagerHolder::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_135_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveGeoManagerHolder*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_135_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoManagerHolder*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_135_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoManagerHolder*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_135_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoManagerHolder*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_135_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoManagerHolder::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_135_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoManagerHolder::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_135_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoManagerHolder::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_135_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoManagerHolder::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGeoManagerHolder G__TTEveGeoManagerHolder;
static int G__G__Eve1_135_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[] (TEveGeoManagerHolder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGeoManagerHolder*) (soff+(sizeof(TEveGeoManagerHolder)*i)))->~G__TTEveGeoManagerHolder();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGeoManagerHolder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGeoManagerHolder*) (soff))->~G__TTEveGeoManagerHolder();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveRefCnt */
static int G__G__Eve1_136_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRefCnt* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRefCnt[n];
     } else {
       p = new((void*) gvp) TEveRefCnt[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRefCnt;
     } else {
       p = new((void*) gvp) TEveRefCnt;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveRefCnt));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_136_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRefCnt* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveRefCnt(*(TEveRefCnt*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEveRefCnt(*(TEveRefCnt*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveRefCnt));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_136_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveRefCnt& obj = ((TEveRefCnt*) G__getstructoffset())->operator=(*(TEveRefCnt*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_136_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRefCnt*) G__getstructoffset())->IncRefCount();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_136_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRefCnt*) G__getstructoffset())->DecRefCount();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_136_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRefCnt*) G__getstructoffset())->OnZeroRefCount();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_136_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveRefCnt::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_136_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRefCnt::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_136_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveRefCnt::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_136_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveRefCnt::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_136_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveRefCnt*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_136_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRefCnt*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_136_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRefCnt*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_136_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRefCnt*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_136_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRefCnt::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_136_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRefCnt::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_136_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRefCnt::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_136_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRefCnt::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveRefCnt G__TTEveRefCnt;
static int G__G__Eve1_136_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[] (TEveRefCnt*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveRefCnt*) (soff+(sizeof(TEveRefCnt)*i)))->~G__TTEveRefCnt();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveRefCnt*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveRefCnt*) (soff))->~G__TTEveRefCnt();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveRefBackPtr */
static int G__G__Eve1_137_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRefBackPtr* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRefBackPtr[n];
     } else {
       p = new((void*) gvp) TEveRefBackPtr[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRefBackPtr;
     } else {
       p = new((void*) gvp) TEveRefBackPtr;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveRefBackPtr));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_137_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRefBackPtr* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveRefBackPtr(*(TEveRefBackPtr*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEveRefBackPtr(*(TEveRefBackPtr*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveRefBackPtr));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_137_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveRefBackPtr& obj = ((TEveRefBackPtr*) G__getstructoffset())->operator=(*(TEveRefBackPtr*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_137_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRefBackPtr*) G__getstructoffset())->IncRefCount((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_137_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRefBackPtr*) G__getstructoffset())->DecRefCount((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_137_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRefBackPtr*) G__getstructoffset())->StampBackPtrElements((UChar_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_137_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveRefBackPtr::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_137_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRefBackPtr::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_137_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveRefBackPtr::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_137_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveRefBackPtr::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_137_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRefBackPtr*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_137_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRefBackPtr::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_137_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRefBackPtr::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_137_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRefBackPtr::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_137_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRefBackPtr::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveRefBackPtr G__TTEveRefBackPtr;
static int G__G__Eve1_137_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[] (TEveRefBackPtr*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveRefBackPtr*) (soff+(sizeof(TEveRefBackPtr)*i)))->~G__TTEveRefBackPtr();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveRefBackPtr*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveRefBackPtr*) (soff))->~G__TTEveRefBackPtr();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveProjection */
static int G__G__Eve1_147_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveProjection*) G__getstructoffset())->Is2D());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveProjection*) G__getstructoffset())->Is3D());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TEveProjection*) G__getstructoffset())->ProjectPoint(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1])
, *(Float_t*) G__Floatref(&libp->para[2]), (Float_t) G__double(libp->para[3])
, (TEveProjection::EPProc_e) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TEveProjection*) G__getstructoffset())->ProjectPoint(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1])
, *(Float_t*) G__Floatref(&libp->para[2]), (Float_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->ProjectPointfv((Float_t*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->ProjectPointdv((Double_t*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->ProjectVector(*(TEveVector*) libp->para[0].ref, (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->ProjectPointfv((TEveTrans*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->ProjectPointdv((TEveTrans*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Float_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->ProjectVector((TEveTrans*) G__int(libp->para[0]), *(TEveVector*) libp->para[1].ref
, (Float_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TEveProjection*) G__getstructoffset())->GetName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->SetName((const Char_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->SetCenter(*(TEveVector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((TEveProjection*) G__getstructoffset())->GetProjectedCenter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->SetType((TEveProjection::EPType_e) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveProjection*) G__getstructoffset())->GetType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->SetGeoMode((TEveProjection::EGeoMode_e) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveProjection*) G__getstructoffset())->GetGeoMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->UpdateLimit();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveProjection*) G__getstructoffset())->GetUsePreScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->SetUsePreScale((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->PreScalePoint(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->PreScalePoint(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1])
, *(Float_t*) G__Floatref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->AddPreScaleEntry((Int_t) G__int(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__Eve1_147_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->ChangePreScaleEntry((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->ClearPreScales();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->SetDistortion((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveProjection*) G__getstructoffset())->GetDistortion());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveProjection*) G__getstructoffset())->GetFixR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveProjection*) G__getstructoffset())->GetFixZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->SetFixR((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->SetFixZ((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveProjection*) G__getstructoffset())->GetPastFixRFac());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveProjection*) G__getstructoffset())->GetPastFixZFac());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->SetPastFixRFac((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->SetPastFixZFac((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveProjection*) G__getstructoffset())->GetMaxTrackStep());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->SetMaxTrackStep((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveProjection*) G__getstructoffset())->HasSeveralSubSpaces());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveProjection*) G__getstructoffset())->AcceptSegment(*(TEveVector*) libp->para[0].ref, *(TEveVector*) libp->para[1].ref
, (Float_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveProjection*) G__getstructoffset())->SubSpaceId(*(TEveVector*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveProjection*) G__getstructoffset())->IsOnSubSpaceBoundrary(*(TEveVector*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TEveProjection*) G__getstructoffset())->BisectBreakPoint(*(TEveVector*) libp->para[0].ref, *(TEveVector*) libp->para[1].ref
, (Float_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TEveProjection*) G__getstructoffset())->BisectBreakPoint(*(TEveVector*) libp->para[0].ref, *(TEveVector*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->SetDirectionalVector((Int_t) G__int(libp->para[0]), *(TEveVector*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TEveProjection*) G__getstructoffset())->GetValForScreenPos((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TEveProjection*) G__getstructoffset())->GetScreenVal((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TEveProjection*) G__getstructoffset())->GetLimit((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveProjection::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjection::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveProjection::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveProjection::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveProjection*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjection::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjection::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjection::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_147_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjection::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveProjection G__TTEveProjection;
static int G__G__Eve1_147_0_61(G__value* result7, G__CONST 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[] (TEveProjection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveProjection*) (soff+(sizeof(TEveProjection)*i)))->~G__TTEveProjection();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveProjection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveProjection*) (soff))->~G__TTEveProjection();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_147_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveProjection* dest = (TEveProjection*) G__getstructoffset();
   *dest = *(TEveProjection*) libp->para[0].ref;
   const TEveProjection& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveProjected */
static int G__G__Eve1_148_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveProjected*) G__getstructoffset())->GetManager());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveProjected*) G__getstructoffset())->GetProjectable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveProjected*) G__getstructoffset())->GetDepth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjected*) G__getstructoffset())->SetProjection((TEveProjectionManager*) G__int(libp->para[0]), (TEveProjectable*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEveProjected*) G__getstructoffset())->UnRefProjectable((TEveProjectable*) G__int(libp->para[0]), (bool) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveProjected*) G__getstructoffset())->UnRefProjectable((TEveProjectable*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjected*) G__getstructoffset())->UpdateProjection();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveProjected*) G__getstructoffset())->GetProjectedAsElement());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjected*) G__getstructoffset())->SetDepth((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveProjected::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjected::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveProjected::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveProjected::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveProjected*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjected*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjected*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjected*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjected::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjected::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjected::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_148_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjected::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveProjected G__TTEveProjected;
static int G__G__Eve1_148_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[] (TEveProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveProjected*) (soff+(sizeof(TEveProjected)*i)))->~G__TTEveProjected();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveProjected*) (soff))->~G__TTEveProjected();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveProjectionManager */
static int G__G__Eve1_149_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveProjectionManager* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveProjectionManager((TEveProjection::EPType_e) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveProjectionManager((TEveProjection::EPType_e) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveProjectionManager[n];
       } else {
         p = new((void*) gvp) TEveProjectionManager[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveProjectionManager;
       } else {
         p = new((void*) gvp) TEveProjectionManager;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManager*) G__getstructoffset())->AddDependent((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManager*) G__getstructoffset())->RemoveDependent((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManager*) G__getstructoffset())->SetProjection((TEveProjection::EPType_e) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveProjectionManager*) G__getstructoffset())->GetProjection());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManager*) G__getstructoffset())->UpdateName();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManager*) G__getstructoffset())->SetCenter((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__Eve1_149_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector& obj = ((TEveProjectionManager*) G__getstructoffset())->GetCenter();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManager*) G__getstructoffset())->SetCurrentDepth((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveProjectionManager*) G__getstructoffset())->GetCurrentDepth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManager*) G__getstructoffset())->SetImportEmpty((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveProjectionManager*) G__getstructoffset())->GetImportEmpty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveProjectionManager*) G__getstructoffset())->ImportElementsRecurse((TEveElement*) G__int(libp->para[0]), (TEveElement*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TEveProjectionManager*) G__getstructoffset())->ImportElements((TEveElement*) G__int(libp->para[0]), (TEveElement*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TEveProjectionManager*) G__getstructoffset())->ImportElements((TEveElement*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveProjectionManager*) G__getstructoffset())->SubImportElements((TEveElement*) G__int(libp->para[0]), (TEveElement*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEveProjectionManager*) G__getstructoffset())->SubImportChildren((TEveElement*) G__int(libp->para[0]), (TEveElement*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManager*) G__getstructoffset())->ProjectChildren();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManager*) G__getstructoffset())->ProjectChildrenRecurse((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveProjectionManager::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectionManager::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveProjectionManager::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveProjectionManager::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectionManager::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjectionManager::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectionManager::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_149_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjectionManager::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveProjectionManager G__TTEveProjectionManager;
static int G__G__Eve1_149_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveProjectionManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveProjectionManager*) (soff+(sizeof(TEveProjectionManager)*i)))->~G__TTEveProjectionManager();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveProjectionManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveProjectionManager*) (soff))->~G__TTEveProjectionManager();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveProjectable */
static int G__G__Eve1_150_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveProjectable*) G__getstructoffset())->ProjectedClass((TEveProjection*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveProjectable*) G__getstructoffset())->HasProjecteds());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveProjectable::ProjList_i* pobj;
         TEveProjectable::ProjList_i xobj = ((TEveProjectable*) G__getstructoffset())->BeginProjecteds();
         pobj = new TEveProjectable::ProjList_i(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__Eve1_150_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveProjectable::ProjList_i* pobj;
         TEveProjectable::ProjList_i xobj = ((TEveProjectable*) G__getstructoffset())->EndProjecteds();
         pobj = new TEveProjectable::ProjList_i(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__Eve1_150_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectable*) G__getstructoffset())->AddProjected((TEveProjected*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectable*) G__getstructoffset())->RemoveProjected((TEveProjected*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectable*) G__getstructoffset())->AnnihilateProjecteds();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectable*) G__getstructoffset())->ClearProjectedList();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectable*) G__getstructoffset())->AddProjectedsToSet(*(set<TEveElement*>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveProjectable*) G__getstructoffset())->PropagateVizParams((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveProjectable*) G__getstructoffset())->PropagateVizParams();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectable*) G__getstructoffset())->PropagateRenderState((Bool_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__Eve1_150_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectable*) G__getstructoffset())->PropagateMainColor((Color_t) G__int(libp->para[0]), (Color_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectable*) G__getstructoffset())->PropagateMainTransparency((Char_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__Eve1_150_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveProjectable::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectable::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveProjectable::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveProjectable::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveProjectable*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectable*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectable*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectable*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectable::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjectable::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectable::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_150_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjectable::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveProjectable G__TTEveProjectable;
static int G__G__Eve1_150_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[] (TEveProjectable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveProjectable*) (soff+(sizeof(TEveProjectable)*i)))->~G__TTEveProjectable();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveProjectable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveProjectable*) (soff))->~G__TTEveProjectable();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> > */
static int G__G__Eve1_156_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >[n];
     } else {
       p = new((void*) gvp) set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >;
     } else {
       p = new((void*) gvp) set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >(*(set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >(*(set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >& obj = ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->operator=(*(set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator* pobj;
         set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator xobj = ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->begin();
         pobj = new set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator* pobj;
         set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator xobj = ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->end();
         pobj = new set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::reverse_iterator* pobj;
         set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::reverse_iterator xobj = ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->rbegin();
         pobj = new set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::reverse_iterator* pobj;
         set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::reverse_iterator xobj = ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->rend();
         pobj = new set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         pair<set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator,bool>* pobj;
         pair<set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator,bool> xobj = ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->insert(libp->para[0].ref ? *(TEveElement**) libp->para[0].ref : *(TEveElement**) (void*) (&G__Mlong(libp->para[0])));
         pobj = new pair<set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator,bool>(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__Eve1_156_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator* pobj;
         set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator xobj = ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->insert(*((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) G__int(libp->para[0])), libp->para[1].ref ? *(TEveElement**) libp->para[1].ref : *(TEveElement**) (void*) (&G__Mlong(libp->para[1])));
         pobj = new set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->erase(*((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->erase(*((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) G__int(libp->para[0])), *((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->swap(*(set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator* pobj;
         const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator xobj = ((const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->find(libp->para[0].ref ? *(TEveElement**) libp->para[0].ref : *(TEveElement**) (void*) (&G__Mlong(libp->para[0])));
         pobj = new set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->count(libp->para[0].ref ? *(TEveElement**) libp->para[0].ref : *(TEveElement**) (void*) (&G__Mlong(libp->para[0]))));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator* pobj;
         const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator xobj = ((const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->lower_bound(libp->para[0].ref ? *(TEveElement**) libp->para[0].ref : *(TEveElement**) (void*) (&G__Mlong(libp->para[0])));
         pobj = new set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_156_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator* pobj;
         const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator xobj = ((const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) G__getstructoffset())->upper_bound(libp->para[0].ref ? *(TEveElement**) libp->para[0].ref : *(TEveElement**) (void*) (&G__Mlong(libp->para[0])));
         pobj = new set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> > G__TsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR;
static int G__G__Eve1_156_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[] (set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) (soff+(sizeof(set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >)*i)))->~G__TsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*) (soff))->~G__TsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator */
static int G__G__Eve1_157_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator[n];
     } else {
       p = new((void*) gvp) set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator;
     } else {
       p = new((void*) gvp) set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_157_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator(*(set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator(*(set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_157_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator& obj = ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator=(*(set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_157_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator*());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_157_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator->());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_157_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator& obj = ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator++();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_157_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator* pobj;
         set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator xobj = ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator++((int) G__int(libp->para[0]));
         pobj = new set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_157_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator& obj = ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator--();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_157_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator* pobj;
         set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator xobj = ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator--((int) G__int(libp->para[0]));
         pobj = new set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_157_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator==(*(set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_157_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator!=(*(set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator G__TsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator;
static int G__G__Eve1_157_0_12(G__value* result7, G__CONST 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[] (set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) (soff+(sizeof(set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator)*i)))->~G__TsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*) (soff))->~G__TsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCompound */
static int G__G__Eve1_167_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCompound* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCompound(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TEveCompound(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCompound(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveCompound(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCompound((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveCompound((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCompound((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveCompound((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveCompound[n];
       } else {
         p = new((void*) gvp) TEveCompound[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveCompound;
       } else {
         p = new((void*) gvp) TEveCompound;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveCompound));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_167_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompound*) G__getstructoffset())->OpenCompound();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_167_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompound*) G__getstructoffset())->CloseCompound();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_167_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveCompound*) G__getstructoffset())->IsCompoundOpen());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_167_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCompound::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_167_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompound::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_167_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCompound::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_167_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCompound::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_167_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompound*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_167_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompound::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_167_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCompound::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_167_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompound::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_167_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCompound::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCompound G__TTEveCompound;
static int G__G__Eve1_167_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[] (TEveCompound*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCompound*) (soff+(sizeof(TEveCompound)*i)))->~G__TTEveCompound();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCompound*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCompound*) (soff))->~G__TTEveCompound();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTrans */
static int G__G__Eve1_168_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrans* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrans[n];
     } else {
       p = new((void*) gvp) TEveTrans[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrans;
     } else {
       p = new((void*) gvp) TEveTrans;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveTrans));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrans* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveTrans(*(TEveTrans*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEveTrans(*(TEveTrans*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveTrans));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrans* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveTrans((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveTrans((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__Eve1LN_TEveTrans));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrans* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveTrans((Float_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveTrans((Float_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__Eve1LN_TEveTrans));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->UnitTrans();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveTrans*) G__getstructoffset())->ZeroTrans((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveTrans*) G__getstructoffset())->ZeroTrans();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->UnitRot();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEveTrans*) G__getstructoffset())->SetTrans(*(TEveTrans*) libp->para[0].ref, (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveTrans*) G__getstructoffset())->SetTrans(*(TEveTrans*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetFromArray((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetFromArray((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveTrans& obj = ((TEveTrans*) G__getstructoffset())->operator=(*(TEveTrans*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetupRotation((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__Eve1_168_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetupFromToVec(*(TEveVector*) libp->para[0].ref, *(TEveVector*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->OrtoNorm3();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TEveTrans*) G__getstructoffset())->Invert());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->MultLeft(*(TEveTrans*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->MultRight(*(TEveTrans*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->operator*=(*(TEveTrans*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->TransposeRotationPart();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveTrans* pobj;
         TEveTrans xobj = ((TEveTrans*) G__getstructoffset())->operator*(*(TEveTrans*) libp->para[0].ref);
         pobj = new TEveTrans(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__Eve1_168_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) 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__Eve1_168_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) 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__Eve1_168_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) 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__Eve1_168_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->MovePF((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__Eve1_168_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->Move3PF((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__Eve1_168_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) 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__Eve1_168_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->Move(*(TEveTrans*) libp->para[0].ref, (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__Eve1_168_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->Move3(*(TEveTrans*) libp->para[0].ref, (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__Eve1_168_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->Rotate(*(TEveTrans*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TEveTrans*) G__getstructoffset())->Array());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TEveTrans*) G__getstructoffset())->Array());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TEveTrans*) G__getstructoffset())->ArrX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TEveTrans*) G__getstructoffset())->ArrX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TEveTrans*) G__getstructoffset())->ArrY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TEveTrans*) G__getstructoffset())->ArrY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TEveTrans*) G__getstructoffset())->ArrZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TEveTrans*) G__getstructoffset())->ArrZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TEveTrans*) G__getstructoffset())->ArrT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TEveTrans*) G__getstructoffset())->ArrT());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveTrans*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TEveTrans*) 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__Eve1_168_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveTrans*) G__getstructoffset())->CM((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TEveTrans*) G__getstructoffset())->CM((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveTrans*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TEveTrans*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) 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__Eve1_168_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetBaseVec((Int_t) G__int(libp->para[0]), *(TVector3*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const TEveTrans*) G__getstructoffset())->GetBaseVec((Int_t) G__int(libp->para[0]));
         pobj = new TVector3(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__Eve1_168_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveTrans*) G__getstructoffset())->GetBaseVec((Int_t) G__int(libp->para[0]), *(TVector3*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetPos((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__Eve1_168_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetPos((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetPos((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetPos(*(TEveTrans*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveTrans*) G__getstructoffset())->GetPos(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveTrans*) G__getstructoffset())->GetPos((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveTrans*) G__getstructoffset())->GetPos((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveTrans*) G__getstructoffset())->GetPos(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const TEveTrans*) G__getstructoffset())->GetPos();
         pobj = new TVector3(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__Eve1_168_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetRotByAngles((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__Eve1_168_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetRotByAnyAngles((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_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__Eve1_168_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveTrans*) G__getstructoffset())->GetRotAngles((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) 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__Eve1_168_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TEveTrans*) G__getstructoffset())->Unscale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->Unscale(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveTrans*) G__getstructoffset())->GetScale(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetScale((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__Eve1_168_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetScaleX((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetScaleY((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetScaleZ((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TEveTrans*) G__getstructoffset())->MultiplyIP(*(TVector3*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TEveTrans*) G__getstructoffset())->MultiplyIP(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TEveTrans*) G__getstructoffset())->MultiplyIP((Double_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TEveTrans*) G__getstructoffset())->MultiplyIP((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TEveTrans*) G__getstructoffset())->MultiplyIP((Float_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TEveTrans*) G__getstructoffset())->MultiplyIP((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const TEveTrans*) G__getstructoffset())->Multiply(*(TVector3*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
         pobj = new TVector3(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const TEveTrans*) G__getstructoffset())->Multiply(*(TVector3*) libp->para[0].ref);
         pobj = new TVector3(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__Eve1_168_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((const TEveTrans*) G__getstructoffset())->Multiply((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((const TEveTrans*) G__getstructoffset())->Multiply((Double_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__Eve1_168_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveTrans*) G__getstructoffset())->RotateIP(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveTrans*) G__getstructoffset())->RotateIP((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveTrans*) G__getstructoffset())->RotateIP((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVector3* pobj;
         const TVector3 xobj = ((const TEveTrans*) G__getstructoffset())->Rotate(*(TVector3*) libp->para[0].ref);
         pobj = new TVector3(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__Eve1_168_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetFrom((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetFrom(*(TGeoMatrix*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetGeoHMatrix(*(TGeoHMatrix*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetBuffer3D(*(TBuffer3D*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrans*) G__getstructoffset())->GetUseTrans());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetUseTrans((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetEditRotation((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetEditScale((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveTrans*) G__getstructoffset())->GetEditRotation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveTrans*) G__getstructoffset())->GetEditScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrans*) G__getstructoffset())->GetEditTrans());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->SetEditTrans((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((const TEveTrans*) G__getstructoffset())->IsScale((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((const TEveTrans*) G__getstructoffset())->IsScale((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((const TEveTrans*) G__getstructoffset())->IsScale());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTrans::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrans::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTrans::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTrans::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrans*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrans::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrans::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrans::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_168_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrans::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTrans G__TTEveTrans;
static int G__G__Eve1_168_0_107(G__value* result7, G__CONST 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[] (TEveTrans*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTrans*) (soff+(sizeof(TEveTrans)*i)))->~G__TTEveTrans();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTrans*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTrans*) (soff))->~G__TTEveTrans();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveManager */
static int G__G__Eve1_170_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveManager* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveManager(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TEveManager(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveManager(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveManager(
(UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveManager((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveManager((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveManager));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetExcHandler());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetSelection());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetHighlight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetOrphanage());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveManager*) G__getstructoffset())->GetUseOrphanage());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->SetUseOrphanage((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->ClearOrphanage();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetBrowser());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetLTEFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetEditor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetStatusBar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetWindowManager());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetScenes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetViewers());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetGlobalScene());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetEventScene());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetCurrentEvent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->SetCurrentEvent((TEveEventManager*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveManager*) G__getstructoffset())->AddCanvasTab((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetMainWindow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetDefaultViewer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetDefaultGLViewer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TEveManager*) G__getstructoffset())->SpawnNewViewer((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TEveManager*) G__getstructoffset())->SpawnNewViewer((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TEveManager*) G__getstructoffset())->SpawnNewViewer((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TEveManager*) G__getstructoffset())->SpawnNewScene((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TEveManager*) G__getstructoffset())->SpawnNewScene((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetMacroFolder());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetMacro((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->EditElement((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->DisableRedraw();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->EnableRedraw();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEveManager*) G__getstructoffset())->Redraw3D((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveManager*) G__getstructoffset())->Redraw3D((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveManager*) G__getstructoffset())->Redraw3D();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->RegisterRedraw3D();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->DoRedraw3D();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEveManager*) G__getstructoffset())->FullRedraw3D((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveManager*) G__getstructoffset())->FullRedraw3D((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveManager*) G__getstructoffset())->FullRedraw3D();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveManager*) G__getstructoffset())->GetKeepEmptyCont());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->SetKeepEmptyCont((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TEveManager*) G__getstructoffset())->ElementChanged((TEveElement*) 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:
      ((TEveManager*) G__getstructoffset())->ElementChanged((TEveElement*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveManager*) G__getstructoffset())->ElementChanged((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->ScenesChanged(*(TEveElement::List_t*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->ElementStamped((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->GetListTree());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TEveManager*) G__getstructoffset())->AddToListTree((TEveElement*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (TGListTree*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TEveManager*) G__getstructoffset())->AddToListTree((TEveElement*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->RemoveFromListTree((TEveElement*) G__int(libp->para[0]), (TGListTree*) G__int(libp->para[1])
, (TGListTreeItem*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveManager*) G__getstructoffset())->AddEvent((TEveEventManager*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEveManager*) G__getstructoffset())->AddElement((TEveElement*) G__int(libp->para[0]), (TEveElement*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveManager*) G__getstructoffset())->AddElement((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEveManager*) G__getstructoffset())->AddGlobalElement((TEveElement*) G__int(libp->para[0]), (TEveElement*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveManager*) G__getstructoffset())->AddGlobalElement((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->RemoveElement((TEveElement*) G__int(libp->para[0]), (TEveElement*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->PreDeleteElement((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->ElementSelect((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveManager*) G__getstructoffset())->ElementPaste((TEveElement*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveManager*) G__getstructoffset())->InsertVizDBEntry(*(TString*) libp->para[0].ref, (TEveElement*) 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__Eve1_170_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveManager*) G__getstructoffset())->InsertVizDBEntry(*(TString*) libp->para[0].ref, (TEveElement*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveManager*) G__getstructoffset())->FindVizDBEntry(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->LoadVizDB(*(TString*) libp->para[0].ref, (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->LoadVizDB(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->SaveVizDB(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveManager*) G__getstructoffset())->GetVizDBReplace());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveManager*) G__getstructoffset())->GetVizDBUpdate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->SetVizDBReplace((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->SetVizDBUpdate((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveManager*) G__getstructoffset())->GetGeometry(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveManager*) G__getstructoffset())->GetGeometryByAlias(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveManager*) G__getstructoffset())->GetDefaultGeometry());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->RegisterGeometryAlias(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->SetStatusLine((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->ClearROOTClassSaved();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->CloseEveWindow();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) TEveManager::Create((Bool_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TEveManager::Create((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) TEveManager::Create());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveManager::Terminate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveManager::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveManager::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveManager::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveManager::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveManager::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveManager::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveManager::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_170_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveManager::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveManager G__TTEveManager;
static int G__G__Eve1_170_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveManager*) (soff+(sizeof(TEveManager)*i)))->~G__TTEveManager();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveManager*) (soff))->~G__TTEveManager();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveElement::TEveListTreeInfo */
static int G__G__Eve1_171_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveElement::TEveListTreeInfo* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveElement::TEveListTreeInfo[n];
     } else {
       p = new((void*) gvp) TEveElement::TEveListTreeInfo[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveElement::TEveListTreeInfo;
     } else {
       p = new((void*) gvp) TEveElement::TEveListTreeInfo;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLTEveListTreeInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_171_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveElement::TEveListTreeInfo* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveElement::TEveListTreeInfo((TGListTree*) G__int(libp->para[0]), (TGListTreeItem*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TEveElement::TEveListTreeInfo((TGListTree*) G__int(libp->para[0]), (TGListTreeItem*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLTEveListTreeInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_171_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveElement::TEveListTreeInfo* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveElement::TEveListTreeInfo(*(TEveElement::TEveListTreeInfo*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEveElement::TEveListTreeInfo(*(TEveElement::TEveListTreeInfo*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLTEveListTreeInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_171_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveElement::TEveListTreeInfo& obj = ((TEveElement::TEveListTreeInfo*) G__getstructoffset())->operator=(*(TEveElement::TEveListTreeInfo*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_171_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement::TEveListTreeInfo*) G__getstructoffset())->operator==(*(TEveElement::TEveListTreeInfo*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_171_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElement::TEveListTreeInfo*) G__getstructoffset())->operator<(*(TEveElement::TEveListTreeInfo*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_171_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveElement::TEveListTreeInfo::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_171_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElement::TEveListTreeInfo::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_171_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveElement::TEveListTreeInfo::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_171_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveElement::TEveListTreeInfo::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_171_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveElement::TEveListTreeInfo*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_171_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement::TEveListTreeInfo*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_171_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement::TEveListTreeInfo*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_171_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElement::TEveListTreeInfo*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_171_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElement::TEveListTreeInfo::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_171_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveElement::TEveListTreeInfo::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_171_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElement::TEveListTreeInfo::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_171_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveElement::TEveListTreeInfo::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveElement::TEveListTreeInfo G__TTEveElementcLcLTEveListTreeInfo;
static int G__G__Eve1_171_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[] (TEveElement::TEveListTreeInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveElement::TEveListTreeInfo*) (soff+(sizeof(TEveElement::TEveListTreeInfo)*i)))->~G__TTEveElementcLcLTEveListTreeInfo();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveElement::TEveListTreeInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveElement::TEveListTreeInfo*) (soff))->~G__TTEveElementcLcLTEveListTreeInfo();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* list<TEveElement*,allocator<TEveElement*> > */
static int G__G__Eve1_179_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   list<TEveElement*,allocator<TEveElement*> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new list<TEveElement*,allocator<TEveElement*> >[n];
     } else {
       p = new((void*) gvp) list<TEveElement*,allocator<TEveElement*> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new list<TEveElement*,allocator<TEveElement*> >;
     } else {
       p = new((void*) gvp) list<TEveElement*,allocator<TEveElement*> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         list<TEveElement*,allocator<TEveElement*> >::iterator* pobj;
         list<TEveElement*,allocator<TEveElement*> >::iterator xobj = ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->begin();
         pobj = new list<TEveElement*,allocator<TEveElement*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         list<TEveElement*,allocator<TEveElement*> >::iterator* pobj;
         list<TEveElement*,allocator<TEveElement*> >::iterator xobj = ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->end();
         pobj = new list<TEveElement*,allocator<TEveElement*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         list<TEveElement*,allocator<TEveElement*> >::reverse_iterator* pobj;
         list<TEveElement*,allocator<TEveElement*> >::reverse_iterator xobj = ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->rbegin();
         pobj = new list<TEveElement*,allocator<TEveElement*> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         list<TEveElement*,allocator<TEveElement*> >::reverse_iterator* pobj;
         list<TEveElement*,allocator<TEveElement*> >::reverse_iterator xobj = ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->rend();
         pobj = new list<TEveElement*,allocator<TEveElement*> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveElement* const& obj = ((const list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveElement* const& obj = ((const list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->swap(*(list<TEveElement*,allocator<TEveElement*> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         list<TEveElement*,allocator<TEveElement*> >::iterator* pobj;
         list<TEveElement*,allocator<TEveElement*> >::iterator xobj = ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->insert(*((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__int(libp->para[0])), libp->para[1].ref ? *(TEveElement**) libp->para[1].ref : *(TEveElement**) (void*) (&G__Mlong(libp->para[1])));
         pobj = new list<TEveElement*,allocator<TEveElement*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->insert(*((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__int(libp->para[0])), (TEveElement**) G__int(libp->para[1])
, (TEveElement**) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->insert(*((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__int(libp->para[0])), *((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__int(libp->para[1]))
, *((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->insert(*((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__int(libp->para[0])), (list<TEveElement*,allocator<TEveElement*> >::size_type) G__int(libp->para[1])
, libp->para[2].ref ? *(TEveElement**) libp->para[2].ref : *(TEveElement**) (void*) (&G__Mlong(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->push_front(libp->para[0].ref ? *(TEveElement**) libp->para[0].ref : *(TEveElement**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->push_back(libp->para[0].ref ? *(TEveElement**) libp->para[0].ref : *(TEveElement**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->resize((list<TEveElement*,allocator<TEveElement*> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->resize((list<TEveElement*,allocator<TEveElement*> >::size_type) G__int(libp->para[0]), (TEveElement*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->erase(*((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->erase(*((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__int(libp->para[0])), *((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->pop_front();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   list<TEveElement*,allocator<TEveElement*> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new list<TEveElement*,allocator<TEveElement*> >((list<TEveElement*,allocator<TEveElement*> >::size_type) G__int(libp->para[0]), libp->para[1].ref ? *(TEveElement**) libp->para[1].ref : *(TEveElement**) (void*) (&G__Mlong(libp->para[1])));
     } else {
       p = new((void*) gvp) list<TEveElement*,allocator<TEveElement*> >((list<TEveElement*,allocator<TEveElement*> >::size_type) G__int(libp->para[0]), libp->para[1].ref ? *(TEveElement**) libp->para[1].ref : *(TEveElement**) (void*) (&G__Mlong(libp->para[1])));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new list<TEveElement*,allocator<TEveElement*> >((list<TEveElement*,allocator<TEveElement*> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) list<TEveElement*,allocator<TEveElement*> >((list<TEveElement*,allocator<TEveElement*> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   list<TEveElement*,allocator<TEveElement*> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new list<TEveElement*,allocator<TEveElement*> >((TEveElement* *const) G__int(libp->para[0]), (TEveElement* *const) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) list<TEveElement*,allocator<TEveElement*> >((TEveElement* *const) G__int(libp->para[0]), (TEveElement* *const) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   list<TEveElement*,allocator<TEveElement*> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new list<TEveElement*,allocator<TEveElement*> >(*((list<TEveElement*,allocator<TEveElement*> >::const_iterator*) G__int(libp->para[0])), *((list<TEveElement*,allocator<TEveElement*> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) list<TEveElement*,allocator<TEveElement*> >(*((list<TEveElement*,allocator<TEveElement*> >::const_iterator*) G__int(libp->para[0])), *((list<TEveElement*,allocator<TEveElement*> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   list<TEveElement*,allocator<TEveElement*> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new list<TEveElement*,allocator<TEveElement*> >(*(list<TEveElement*,allocator<TEveElement*> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) list<TEveElement*,allocator<TEveElement*> >(*(list<TEveElement*,allocator<TEveElement*> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const list<TEveElement*,allocator<TEveElement*> >& obj = ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->operator=(*(list<TEveElement*,allocator<TEveElement*> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->splice(*((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__int(libp->para[0])), *(list<TEveElement*,allocator<TEveElement*> >*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->splice(*((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__int(libp->para[0])), *(list<TEveElement*,allocator<TEveElement*> >*) libp->para[1].ref
, *((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->splice(*((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__int(libp->para[0])), *(list<TEveElement*,allocator<TEveElement*> >*) libp->para[1].ref
, *((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__int(libp->para[2])), *((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__int(libp->para[3])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->remove(libp->para[0].ref ? *(TEveElement**) libp->para[0].ref : *(TEveElement**) (void*) (&G__Mlong(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->unique();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->merge(*(list<TEveElement*,allocator<TEveElement*> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->reverse();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_179_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((list<TEveElement*,allocator<TEveElement*> >*) G__getstructoffset())->sort();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef list<TEveElement*,allocator<TEveElement*> > G__TlistlETEveElementmUcOallocatorlETEveElementmUgRsPgR;
static int G__G__Eve1_179_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (list<TEveElement*,allocator<TEveElement*> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((list<TEveElement*,allocator<TEveElement*> >*) (soff+(sizeof(list<TEveElement*,allocator<TEveElement*> >)*i)))->~G__TlistlETEveElementmUcOallocatorlETEveElementmUgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (list<TEveElement*,allocator<TEveElement*> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((list<TEveElement*,allocator<TEveElement*> >*) (soff))->~G__TlistlETEveElementmUcOallocatorlETEveElementmUgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* list<TEveElement*,allocator<TEveElement*> >::iterator */
static int G__G__Eve1_180_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   list<TEveElement*,allocator<TEveElement*> >::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new list<TEveElement*,allocator<TEveElement*> >::iterator[n];
     } else {
       p = new((void*) gvp) list<TEveElement*,allocator<TEveElement*> >::iterator[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new list<TEveElement*,allocator<TEveElement*> >::iterator;
     } else {
       p = new((void*) gvp) list<TEveElement*,allocator<TEveElement*> >::iterator;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_180_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   list<TEveElement*,allocator<TEveElement*> >::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new list<TEveElement*,allocator<TEveElement*> >::iterator(*(list<TEveElement*,allocator<TEveElement*> >::iterator*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) list<TEveElement*,allocator<TEveElement*> >::iterator(*(list<TEveElement*,allocator<TEveElement*> >::iterator*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_180_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const list<TEveElement*,allocator<TEveElement*> >::iterator& obj = ((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator=(*(list<TEveElement*,allocator<TEveElement*> >::iterator*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_180_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveElement* const& obj = ((const list<TEveElement*,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator*();
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_180_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const list<TEveElement*,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator->());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_180_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const list<TEveElement*,allocator<TEveElement*> >::iterator& obj = ((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator++();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_180_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         list<TEveElement*,allocator<TEveElement*> >::iterator* pobj;
         list<TEveElement*,allocator<TEveElement*> >::iterator xobj = ((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator++((int) G__int(libp->para[0]));
         pobj = new list<TEveElement*,allocator<TEveElement*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_180_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const list<TEveElement*,allocator<TEveElement*> >::iterator& obj = ((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator--();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_180_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         list<TEveElement*,allocator<TEveElement*> >::iterator* pobj;
         list<TEveElement*,allocator<TEveElement*> >::iterator xobj = ((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator--((int) G__int(libp->para[0]));
         pobj = new list<TEveElement*,allocator<TEveElement*> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_180_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator==(*(list<TEveElement*,allocator<TEveElement*> >::iterator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_180_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((list<TEveElement*,allocator<TEveElement*> >::iterator*) G__getstructoffset())->operator!=(*(list<TEveElement*,allocator<TEveElement*> >::iterator*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef list<TEveElement*,allocator<TEveElement*> >::iterator G__TlistlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator;
static int G__G__Eve1_180_0_12(G__value* result7, G__CONST 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[] (list<TEveElement*,allocator<TEveElement*> >::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((list<TEveElement*,allocator<TEveElement*> >::iterator*) (soff+(sizeof(list<TEveElement*,allocator<TEveElement*> >::iterator)*i)))->~G__TlistlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (list<TEveElement*,allocator<TEveElement*> >::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((list<TEveElement*,allocator<TEveElement*> >::iterator*) (soff))->~G__TlistlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveElementObjectPtr */
static int G__G__Eve1_185_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveElementObjectPtr* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveElementObjectPtr((TObject*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveElementObjectPtr((TObject*) 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 TEveElementObjectPtr((TObject*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveElementObjectPtr((TObject*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementObjectPtr));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_185_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveElementObjectPtr* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveElementObjectPtr(
(TObject*) G__int(libp->para[0]), *(Color_t*) G__Shortref(&libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveElementObjectPtr(
(TObject*) G__int(libp->para[0]), *(Color_t*) G__Shortref(&libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveElementObjectPtr((TObject*) G__int(libp->para[0]), *(Color_t*) G__Shortref(&libp->para[1]));
     } else {
       p = new((void*) gvp) TEveElementObjectPtr((TObject*) G__int(libp->para[0]), *(Color_t*) G__Shortref(&libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementObjectPtr));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_185_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveElementObjectPtr* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveElementObjectPtr(*(TEveElementObjectPtr*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEveElementObjectPtr(*(TEveElementObjectPtr*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementObjectPtr));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_185_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TEveElementObjectPtr*) G__getstructoffset())->GetObject(*(TEveException*) libp->para[0].ref));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TEveElementObjectPtr*) G__getstructoffset())->GetObject());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_185_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveElementObjectPtr*) G__getstructoffset())->GetOwnObject());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_185_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElementObjectPtr*) G__getstructoffset())->SetOwnObject((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_185_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveElementObjectPtr::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_185_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElementObjectPtr::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_185_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveElementObjectPtr::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_185_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveElementObjectPtr::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_185_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElementObjectPtr*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_185_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElementObjectPtr::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_185_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveElementObjectPtr::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_185_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElementObjectPtr::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_185_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveElementObjectPtr::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveElementObjectPtr G__TTEveElementObjectPtr;
static int G__G__Eve1_185_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[] (TEveElementObjectPtr*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveElementObjectPtr*) (soff+(sizeof(TEveElementObjectPtr)*i)))->~G__TTEveElementObjectPtr();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveElementObjectPtr*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveElementObjectPtr*) (soff))->~G__TTEveElementObjectPtr();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveElementList */
static int G__G__Eve1_186_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveElementList* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveElementList(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TEveElementList(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveElementList(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveElementList(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveElementList((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveElementList((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveElementList((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveElementList((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveElementList[n];
       } else {
         p = new((void*) gvp) TEveElementList[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveElementList;
       } else {
         p = new((void*) gvp) TEveElementList;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_186_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveElementList* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveElementList(*(TEveElementList*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEveElementList(*(TEveElementList*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_186_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TEveElementList*) G__getstructoffset())->GetObject(*(TEveException*) libp->para[0].ref));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TEveElementList*) G__getstructoffset())->GetObject());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_186_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveElementList*) G__getstructoffset())->GetChildClass());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_186_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElementList*) G__getstructoffset())->SetChildClass((TClass*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_186_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveElementList::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_186_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElementList::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_186_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveElementList::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_186_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveElementList::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_186_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElementList*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_186_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElementList::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_186_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveElementList::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_186_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElementList::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_186_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveElementList::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveElementList G__TTEveElementList;
static int G__G__Eve1_186_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveElementList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveElementList*) (soff+(sizeof(TEveElementList)*i)))->~G__TTEveElementList();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveElementList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveElementList*) (soff))->~G__TTEveElementList();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveElementListProjected */
static int G__G__Eve1_187_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveElementListProjected* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveElementListProjected[n];
     } else {
       p = new((void*) gvp) TEveElementListProjected[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveElementListProjected;
     } else {
       p = new((void*) gvp) TEveElementListProjected;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementListProjected));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_187_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveElementListProjected::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_187_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElementListProjected::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_187_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveElementListProjected::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_187_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveElementListProjected::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_187_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElementListProjected*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_187_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElementListProjected::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_187_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveElementListProjected::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_187_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElementListProjected::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_187_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveElementListProjected::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveElementListProjected G__TTEveElementListProjected;
static int G__G__Eve1_187_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[] (TEveElementListProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveElementListProjected*) (soff+(sizeof(TEveElementListProjected)*i)))->~G__TTEveElementListProjected();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveElementListProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveElementListProjected*) (soff))->~G__TTEveElementListProjected();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGedEditor */
static int G__G__Eve1_320_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGedEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGedEditor(
(TCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveGedEditor(
(TCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGedEditor((TCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveGedEditor((TCanvas*) 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 TEveGedEditor((TCanvas*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveGedEditor((TCanvas*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGedEditor[n];
       } else {
         p = new((void*) gvp) TEveGedEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGedEditor;
       } else {
         p = new((void*) gvp) TEveGedEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_320_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveGedEditor*) G__getstructoffset())->GetEveElement());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_320_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGedEditor*) G__getstructoffset())->DisplayElement((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_320_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGedEditor*) G__getstructoffset())->DisplayObject((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_320_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGedEditor::SpawnNewEditor((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_320_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGedEditor::ElementChanged((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_320_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGedEditor::ElementDeleted((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_320_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGedEditor::DestroyEditors();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_320_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGedEditor::GetContextMenu());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_320_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGedEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_320_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGedEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_320_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGedEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_320_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGedEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_320_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGedEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_320_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGedEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_320_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGedEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_320_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGedEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_320_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGedEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGedEditor G__TTEveGedEditor;
static int G__G__Eve1_320_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveGedEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGedEditor*) (soff+(sizeof(TEveGedEditor)*i)))->~G__TTEveGedEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGedEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGedEditor*) (soff))->~G__TTEveGedEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveListTreeItem */
static int G__G__Eve1_321_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveListTreeItem* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveListTreeItem((TEveElement*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveListTreeItem((TEveElement*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveListTreeItem));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_321_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveListTreeItem::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_321_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveListTreeItem::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_321_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveListTreeItem::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_321_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveListTreeItem::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_321_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveListTreeItem*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_321_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveListTreeItem::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_321_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveListTreeItem::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_321_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveListTreeItem::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_321_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveListTreeItem::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveListTreeItem G__TTEveListTreeItem;
static int G__G__Eve1_321_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[] (TEveListTreeItem*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveListTreeItem*) (soff+(sizeof(TEveListTreeItem)*i)))->~G__TTEveListTreeItem();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveListTreeItem*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveListTreeItem*) (soff))->~G__TTEveListTreeItem();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGListTreeEditorFrame */
static int G__G__Eve1_322_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGListTreeEditorFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGListTreeEditorFrame(
(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) TEveGListTreeEditorFrame(
(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 TEveGListTreeEditorFrame((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveGListTreeEditorFrame((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 TEveGListTreeEditorFrame((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveGListTreeEditorFrame((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGListTreeEditorFrame[n];
       } else {
         p = new((void*) gvp) TEveGListTreeEditorFrame[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGListTreeEditorFrame;
       } else {
         p = new((void*) gvp) TEveGListTreeEditorFrame;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveGListTreeEditorFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGListTreeEditorFrame*) G__getstructoffset())->ConnectSignals();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGListTreeEditorFrame*) G__getstructoffset())->DisconnectSignals();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGListTreeEditorFrame*) G__getstructoffset())->ReconfToHorizontal();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGListTreeEditorFrame*) G__getstructoffset())->ReconfToVertical();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveGListTreeEditorFrame*) G__getstructoffset())->GetListTree());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveGListTreeEditorFrame*) G__getstructoffset())->GetEditor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGListTreeEditorFrame*) G__getstructoffset())->ItemBelowMouse((TGListTreeItem*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGListTreeEditorFrame*) G__getstructoffset())->ItemClicked((TGListTreeItem*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGListTreeEditorFrame*) G__getstructoffset())->ItemDblClicked((TGListTreeItem*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGListTreeEditorFrame*) G__getstructoffset())->ItemKeyPress((TGListTreeItem*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGListTreeEditorFrame::SetEditorClass((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGListTreeEditorFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGListTreeEditorFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGListTreeEditorFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGListTreeEditorFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGListTreeEditorFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGListTreeEditorFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGListTreeEditorFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGListTreeEditorFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_322_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGListTreeEditorFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGListTreeEditorFrame G__TTEveGListTreeEditorFrame;
static int G__G__Eve1_322_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveGListTreeEditorFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGListTreeEditorFrame*) (soff+(sizeof(TEveGListTreeEditorFrame)*i)))->~G__TTEveGListTreeEditorFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGListTreeEditorFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGListTreeEditorFrame*) (soff))->~G__TTEveGListTreeEditorFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveBrowser */
static int G__G__Eve1_323_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveBrowser* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveBrowser((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TEveBrowser((UInt_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_323_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveBrowser*) G__getstructoffset())->InitPlugins((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveBrowser*) G__getstructoffset())->InitPlugins();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_323_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveBrowser*) G__getstructoffset())->MakeFileBrowser());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_323_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveBrowser*) G__getstructoffset())->GetFileBrowser());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_323_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBrowser*) G__getstructoffset())->EveMenu((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_323_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveBrowser*) G__getstructoffset())->GetMenuBar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_323_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveBrowser*) G__getstructoffset())->GetTopMenuFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_323_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBrowser*) G__getstructoffset())->HideBottomTab();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_323_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveBrowser::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_323_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBrowser::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_323_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveBrowser::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_323_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveBrowser::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_323_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBrowser*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_323_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBrowser::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_323_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveBrowser::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_323_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBrowser::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_323_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveBrowser::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveBrowser G__TTEveBrowser;
static int G__G__Eve1_323_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[] (TEveBrowser*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveBrowser*) (soff+(sizeof(TEveBrowser)*i)))->~G__TTEveBrowser();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveBrowser*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveBrowser*) (soff))->~G__TTEveBrowser();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveChunkManager */
static int G__G__Eve1_326_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveChunkManager* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveChunkManager[n];
     } else {
       p = new((void*) gvp) TEveChunkManager[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveChunkManager;
     } else {
       p = new((void*) gvp) TEveChunkManager;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManager));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveChunkManager* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveChunkManager((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TEveChunkManager((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManager));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveChunkManager*) G__getstructoffset())->Reset((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__Eve1_326_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveChunkManager*) G__getstructoffset())->Refit();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveChunkManager*) G__getstructoffset())->S());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveChunkManager*) G__getstructoffset())->N());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveChunkManager*) G__getstructoffset())->Size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveChunkManager*) G__getstructoffset())->VecSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveChunkManager*) G__getstructoffset())->Capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TEveChunkManager*) G__getstructoffset())->Atom((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TEveChunkManager*) G__getstructoffset())->Chunk((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveChunkManager*) G__getstructoffset())->NAtoms((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TEveChunkManager*) G__getstructoffset())->NewAtom());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TEveChunkManager*) G__getstructoffset())->NewChunk());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveChunkManager::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveChunkManager::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveChunkManager::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveChunkManager::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveChunkManager*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveChunkManager*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveChunkManager*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveChunkManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveChunkManager::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveChunkManager::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveChunkManager::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_326_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveChunkManager::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveChunkManager G__TTEveChunkManager;
static int G__G__Eve1_326_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[] (TEveChunkManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveChunkManager*) (soff+(sizeof(TEveChunkManager)*i)))->~G__TTEveChunkManager();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveChunkManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveChunkManager*) (soff))->~G__TTEveChunkManager();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveChunkManager::iterator */
static int G__G__Eve1_331_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveChunkManager::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveChunkManager::iterator((TEveChunkManager*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveChunkManager::iterator((TEveChunkManager*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManagercLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_331_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveChunkManager::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveChunkManager::iterator(*(TEveChunkManager*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEveChunkManager::iterator(*(TEveChunkManager*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManagercLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_331_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveChunkManager::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveChunkManager::iterator(*(TEveChunkManager::iterator*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEveChunkManager::iterator(*(TEveChunkManager::iterator*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManagercLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_331_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveChunkManager::iterator& obj = ((TEveChunkManager::iterator*) G__getstructoffset())->operator=(*(TEveChunkManager::iterator*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_331_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveChunkManager::iterator*) G__getstructoffset())->next());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_331_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveChunkManager::iterator*) G__getstructoffset())->reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_331_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TEveChunkManager::iterator*) G__getstructoffset())->operator()());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_331_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TEveChunkManager::iterator*) G__getstructoffset())->operator*());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_331_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEveChunkManager::iterator*) G__getstructoffset())->index());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveChunkManager::iterator G__TTEveChunkManagercLcLiterator;
static int G__G__Eve1_331_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveChunkManager::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveChunkManager::iterator*) (soff+(sizeof(TEveChunkManager::iterator)*i)))->~G__TTEveChunkManagercLcLiterator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveChunkManager::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveChunkManager::iterator*) (soff))->~G__TTEveChunkManagercLcLiterator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCompoundProjected */
static int G__G__Eve1_339_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCompoundProjected* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCompoundProjected[n];
     } else {
       p = new((void*) gvp) TEveCompoundProjected[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCompoundProjected;
     } else {
       p = new((void*) gvp) TEveCompoundProjected;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveCompoundProjected));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_339_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCompoundProjected::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_339_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompoundProjected::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_339_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCompoundProjected::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_339_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCompoundProjected::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_339_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompoundProjected*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_339_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompoundProjected::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_339_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCompoundProjected::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_339_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompoundProjected::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_339_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCompoundProjected::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCompoundProjected G__TTEveCompoundProjected;
static int G__G__Eve1_339_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[] (TEveCompoundProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCompoundProjected*) (soff+(sizeof(TEveCompoundProjected)*i)))->~G__TTEveCompoundProjected();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCompoundProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCompoundProjected*) (soff))->~G__TTEveCompoundProjected();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTransSubEditor */
static int G__G__Eve1_349_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTransSubEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveTransSubEditor((TGWindow*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveTransSubEditor((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__Eve1LN_TEveTransSubEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTransSubEditor*) G__getstructoffset())->SetModel((TEveTrans*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTransSubEditor*) G__getstructoffset())->SetTransFromData();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTransSubEditor*) G__getstructoffset())->UseTrans();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTransSubEditor*) G__getstructoffset())->TransChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTransSubEditor*) G__getstructoffset())->DoUseTrans();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTransSubEditor*) G__getstructoffset())->DoEditTrans();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTransSubEditor*) G__getstructoffset())->DoTransChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveTransSubEditor*) G__getstructoffset())->GetPosValuator());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveTransSubEditor*) G__getstructoffset())->GetRotValuator());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveTransSubEditor*) G__getstructoffset())->GetScaleValuator());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTransSubEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTransSubEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTransSubEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTransSubEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTransSubEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTransSubEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTransSubEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTransSubEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_349_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTransSubEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTransSubEditor G__TTEveTransSubEditor;
static int G__G__Eve1_349_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[] (TEveTransSubEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTransSubEditor*) (soff+(sizeof(TEveTransSubEditor)*i)))->~G__TTEveTransSubEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTransSubEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTransSubEditor*) (soff))->~G__TTEveTransSubEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveElementEditor */
static int G__G__Eve1_350_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveElementEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveElementEditor(
(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) TEveElementEditor(
(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 TEveElementEditor(
(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) TEveElementEditor(
(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 TEveElementEditor(
(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) TEveElementEditor(
(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 TEveElementEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveElementEditor((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 TEveElementEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveElementEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveElementEditor[n];
       } else {
         p = new((void*) gvp) TEveElementEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveElementEditor;
       } else {
         p = new((void*) gvp) TEveElementEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_350_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElementEditor*) G__getstructoffset())->DoRnrSelf();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_350_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElementEditor*) G__getstructoffset())->DoRnrChildren();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_350_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElementEditor*) G__getstructoffset())->DoRnrState();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_350_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElementEditor*) G__getstructoffset())->DoMainColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_350_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElementEditor*) G__getstructoffset())->DoTransparency();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_350_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveElementEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_350_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElementEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_350_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveElementEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_350_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveElementEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_350_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveElementEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_350_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElementEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_350_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveElementEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_350_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveElementEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_350_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveElementEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveElementEditor G__TTEveElementEditor;
static int G__G__Eve1_350_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[] (TEveElementEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveElementEditor*) (soff+(sizeof(TEveElementEditor)*i)))->~G__TTEveElementEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveElementEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveElementEditor*) (soff))->~G__TTEveElementEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveEventManager */
static int G__G__Eve1_351_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveEventManager* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveEventManager((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveEventManager((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveEventManager((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveEventManager((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveEventManager[n];
       } else {
         p = new((void*) gvp) TEveEventManager[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveEventManager;
       } else {
         p = new((void*) gvp) TEveEventManager;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveEventManager));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TString>& obj = ((TEveEventManager*) G__getstructoffset())->GetNewEventCommands();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveEventManager*) G__getstructoffset())->Open();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveEventManager*) G__getstructoffset())->GotoEvent((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveEventManager*) G__getstructoffset())->NextEvent();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveEventManager*) G__getstructoffset())->PrevEvent();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveEventManager*) G__getstructoffset())->Close();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveEventManager*) G__getstructoffset())->AfterNewEventLoaded();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveEventManager*) G__getstructoffset())->AddNewEventCommand(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveEventManager*) G__getstructoffset())->RemoveNewEventCommand(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveEventManager*) G__getstructoffset())->ClearNewEventCommands();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveEventManager::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveEventManager::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveEventManager::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveEventManager::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveEventManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveEventManager::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveEventManager::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveEventManager::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_351_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveEventManager::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveEventManager G__TTEveEventManager;
static int G__G__Eve1_351_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[] (TEveEventManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveEventManager*) (soff+(sizeof(TEveEventManager)*i)))->~G__TTEveEventManager();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveEventManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveEventManager*) (soff))->~G__TTEveEventManager();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGValuatorBase */
static int G__G__Eve1_377_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveGValuatorBase*) G__getstructoffset())->Build((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveGValuatorBase*) G__getstructoffset())->Build();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_377_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGValuatorBase*) G__getstructoffset())->SetLabelWidth((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_377_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGValuatorBase*) G__getstructoffset())->SetAlignRight((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_377_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveGValuatorBase*) G__getstructoffset())->SetShowSlider((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveGValuatorBase*) G__getstructoffset())->SetShowSlider();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_377_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGValuatorBase*) G__getstructoffset())->SetNELength((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_377_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGValuatorBase*) G__getstructoffset())->SetNEHeight((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_377_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveGValuatorBase*) G__getstructoffset())->GetLabel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_377_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGValuatorBase::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_377_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGValuatorBase::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_377_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGValuatorBase::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_377_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGValuatorBase::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_377_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGValuatorBase*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_377_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGValuatorBase::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_377_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGValuatorBase::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_377_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGValuatorBase::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_377_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGValuatorBase::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGValuatorBase G__TTEveGValuatorBase;
static int G__G__Eve1_377_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveGValuatorBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGValuatorBase*) (soff+(sizeof(TEveGValuatorBase)*i)))->~G__TTEveGValuatorBase();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGValuatorBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGValuatorBase*) (soff))->~G__TTEveGValuatorBase();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGValuator */
static int G__G__Eve1_378_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGValuator* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGValuator(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TEveGValuator(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGValuator(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TEveGValuator(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveGValuator*) G__getstructoffset())->GetValue());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEveGValuator*) G__getstructoffset())->SetValue((Float_t) G__double(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveGValuator*) G__getstructoffset())->SetValue((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGValuator*) G__getstructoffset())->SliderCallback();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGValuator*) G__getstructoffset())->EntryCallback();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGValuator*) G__getstructoffset())->ValueSet((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveGValuator*) G__getstructoffset())->GetSlider());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveGValuator*) G__getstructoffset())->GetEntry());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGValuator*) G__getstructoffset())->SetSliderNewLine((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveGValuator*) G__getstructoffset())->GetLimits(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveGValuator*) G__getstructoffset())->GetLimitMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveGValuator*) G__getstructoffset())->GetLimitMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGValuator*) G__getstructoffset())->SetLimits((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__Eve1_378_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TEveGValuator*) G__getstructoffset())->SetLimits((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TGNumberFormat::EStyle) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TEveGValuator*) G__getstructoffset())->SetLimits((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;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGValuator*) G__getstructoffset())->SetToolTip((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGValuator*) G__getstructoffset())->SetEnabled((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGValuator::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGValuator::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGValuator::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGValuator::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGValuator*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGValuator::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGValuator::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGValuator::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_378_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGValuator::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGValuator G__TTEveGValuator;
static int G__G__Eve1_378_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[] (TEveGValuator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGValuator*) (soff+(sizeof(TEveGValuator)*i)))->~G__TTEveGValuator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGValuator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGValuator*) (soff))->~G__TTEveGValuator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGDoubleValuator */
static int G__G__Eve1_379_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGDoubleValuator* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGDoubleValuator(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TEveGDoubleValuator(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGDoubleValuator(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TEveGDoubleValuator(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveGDoubleValuator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGDoubleValuator*) G__getstructoffset())->MinEntryCallback();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGDoubleValuator*) G__getstructoffset())->MaxEntryCallback();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGDoubleValuator*) G__getstructoffset())->SliderCallback();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGDoubleValuator*) G__getstructoffset())->ValueSet();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveGDoubleValuator*) G__getstructoffset())->GetSlider());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveGDoubleValuator*) G__getstructoffset())->GetMinEntry());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveGDoubleValuator*) G__getstructoffset())->GetMaxEntry());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGDoubleValuator*) G__getstructoffset())->SetLimits((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__Eve1_379_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TEveGDoubleValuator*) G__getstructoffset())->SetLimits((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (TGNumberFormat::EStyle) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TEveGDoubleValuator*) G__getstructoffset())->SetLimits((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TEveGDoubleValuator*) G__getstructoffset())->SetValues((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TEveGDoubleValuator*) G__getstructoffset())->SetValues((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveGDoubleValuator*) G__getstructoffset())->GetValues(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveGDoubleValuator*) G__getstructoffset())->GetMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveGDoubleValuator*) G__getstructoffset())->GetMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveGDoubleValuator*) G__getstructoffset())->GetLimitMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveGDoubleValuator*) G__getstructoffset())->GetLimitMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGDoubleValuator::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGDoubleValuator::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGDoubleValuator::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGDoubleValuator::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGDoubleValuator*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGDoubleValuator::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGDoubleValuator::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGDoubleValuator::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_379_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGDoubleValuator::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGDoubleValuator G__TTEveGDoubleValuator;
static int G__G__Eve1_379_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveGDoubleValuator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGDoubleValuator*) (soff+(sizeof(TEveGDoubleValuator)*i)))->~G__TTEveGDoubleValuator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGDoubleValuator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGDoubleValuator*) (soff))->~G__TTEveGDoubleValuator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGTriVecValuator */
static int G__G__Eve1_380_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGTriVecValuator* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGTriVecValuator(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TEveGTriVecValuator(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGTriVecValuator(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TEveGTriVecValuator(
(TGWindow*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGTriVecValuator*) G__getstructoffset())->Build((Bool_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveGTriVecValuator*) G__getstructoffset())->GetValuator((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveGTriVecValuator*) G__getstructoffset())->GetValue((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGTriVecValuator*) G__getstructoffset())->SetValue((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveGTriVecValuator*) G__getstructoffset())->GetValues(*(Float_t*) G__Floatref(&libp->para[0]), *(Float_t*) G__Floatref(&libp->para[1])
, *(Float_t*) G__Floatref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveGTriVecValuator*) G__getstructoffset())->GetValues((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveGTriVecValuator*) G__getstructoffset())->GetValues((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGTriVecValuator*) G__getstructoffset())->SetValues((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__Eve1_380_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGTriVecValuator*) G__getstructoffset())->SetValues((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGTriVecValuator*) G__getstructoffset())->SetValues((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGTriVecValuator*) G__getstructoffset())->ValueSet();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGTriVecValuator*) G__getstructoffset())->SetLabelWidth((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGTriVecValuator*) G__getstructoffset())->SetNELength((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGTriVecValuator*) G__getstructoffset())->SetNEHeight((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGTriVecValuator*) G__getstructoffset())->SetLimits((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__Eve1_380_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TEveGTriVecValuator*) G__getstructoffset())->SetLimits((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (TGNumberFormat::EStyle) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TEveGTriVecValuator*) G__getstructoffset())->SetLimits((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGTriVecValuator::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGTriVecValuator::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGTriVecValuator::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGTriVecValuator::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGTriVecValuator*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGTriVecValuator::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGTriVecValuator::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGTriVecValuator::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_380_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGTriVecValuator::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGTriVecValuator G__TTEveGTriVecValuator;
static int G__G__Eve1_380_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveGTriVecValuator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGTriVecValuator*) (soff+(sizeof(TEveGTriVecValuator)*i)))->~G__TTEveGTriVecValuator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGTriVecValuator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGTriVecValuator*) (soff))->~G__TTEveGTriVecValuator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGedNameFrame */
static int G__G__Eve1_389_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGedNameFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGedNameFrame(
(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) TEveGedNameFrame(
(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 TEveGedNameFrame(
(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) TEveGedNameFrame(
(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 TEveGedNameFrame((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveGedNameFrame((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 TEveGedNameFrame((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveGedNameFrame((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGedNameFrame[n];
       } else {
         p = new((void*) gvp) TEveGedNameFrame[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGedNameFrame;
       } else {
         p = new((void*) gvp) TEveGedNameFrame;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_389_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGedNameFrame*) G__getstructoffset())->SpawnEditorClone();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_389_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGedNameFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_389_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGedNameFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_389_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGedNameFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_389_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGedNameFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_389_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGedNameFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_389_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGedNameFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_389_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGedNameFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_389_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGedNameFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_389_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGedNameFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGedNameFrame G__TTEveGedNameFrame;
static int G__G__Eve1_389_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[] (TEveGedNameFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGedNameFrame*) (soff+(sizeof(TEveGedNameFrame)*i)))->~G__TTEveGedNameFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGedNameFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGedNameFrame*) (soff))->~G__TTEveGedNameFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGedNameTextButton */
static int G__G__Eve1_390_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGedNameTextButton* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveGedNameTextButton((TEveGedNameFrame*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveGedNameTextButton((TEveGedNameFrame*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameTextButton));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_390_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGedNameTextButton::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_390_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGedNameTextButton::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_390_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGedNameTextButton::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_390_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGedNameTextButton::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_390_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGedNameTextButton*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_390_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGedNameTextButton::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_390_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGedNameTextButton::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_390_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGedNameTextButton::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_390_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGedNameTextButton::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGedNameTextButton G__TTEveGedNameTextButton;
static int G__G__Eve1_390_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[] (TEveGedNameTextButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGedNameTextButton*) (soff+(sizeof(TEveGedNameTextButton)*i)))->~G__TTEveGedNameTextButton();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGedNameTextButton*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGedNameTextButton*) (soff))->~G__TTEveGedNameTextButton();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveMacro */
static int G__G__Eve1_393_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveMacro* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveMacro[n];
     } else {
       p = new((void*) gvp) TEveMacro[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveMacro;
     } else {
       p = new((void*) gvp) TEveMacro;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveMacro));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_393_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveMacro* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveMacro(*(TEveMacro*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEveMacro(*(TEveMacro*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveMacro));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_393_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveMacro* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveMacro((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveMacro((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveMacro));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_393_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveMacro*) G__getstructoffset())->ResetRoot();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_393_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveMacro::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_393_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMacro::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_393_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveMacro::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_393_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveMacro::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_393_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveMacro*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_393_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMacro::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_393_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveMacro::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_393_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMacro::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_393_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveMacro::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveMacro G__TTEveMacro;
static int G__G__Eve1_393_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[] (TEveMacro*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveMacro*) (soff+(sizeof(TEveMacro)*i)))->~G__TTEveMacro();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveMacro*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveMacro*) (soff))->~G__TTEveMacro();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_393_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveMacro* dest = (TEveMacro*) G__getstructoffset();
   *dest = *(TEveMacro*) libp->para[0].ref;
   const TEveMacro& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveSelection */
static int G__G__Eve1_415_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveSelection* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveSelection((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveSelection((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveSelection((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveSelection((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveSelection[n];
       } else {
         p = new((void*) gvp) TEveSelection[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveSelection;
       } else {
         p = new((void*) gvp) TEveSelection;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSelection*) G__getstructoffset())->SetHighlightMode();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveSelection*) G__getstructoffset())->GetPickToSelect());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSelection*) G__getstructoffset())->SetPickToSelect((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveSelection*) G__getstructoffset())->GetIsMaster());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSelection*) G__getstructoffset())->SetIsMaster((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSelection*) G__getstructoffset())->RemoveImpliedSelected((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSelection*) G__getstructoffset())->RecheckImpliedSetForElement((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSelection*) G__getstructoffset())->SelectionAdded((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSelection*) G__getstructoffset())->SelectionRemoved((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSelection*) G__getstructoffset())->SelectionCleared();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSelection*) G__getstructoffset())->SelectionRepeated((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSelection*) G__getstructoffset())->ActivateSelection();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSelection*) G__getstructoffset())->DeactivateSelection();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveSelection*) G__getstructoffset())->MapPickedToSelected((TEveElement*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEveSelection*) G__getstructoffset())->UserPickedElement((TEveElement*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveSelection*) G__getstructoffset())->UserPickedElement((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSelection*) G__getstructoffset())->UserRePickedElement((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSelection*) G__getstructoffset())->UserUnPickedElement((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveSelection::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveSelection::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveSelection::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveSelection::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSelection*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveSelection::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveSelection::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveSelection::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_415_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveSelection::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveSelection G__TTEveSelection;
static int G__G__Eve1_415_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[] (TEveSelection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveSelection*) (soff+(sizeof(TEveSelection)*i)))->~G__TTEveSelection();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveSelection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveSelection*) (soff))->~G__TTEveSelection();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveViewer */
static int G__G__Eve1_416_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveViewer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveViewer((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveViewer((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveViewer((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveViewer((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveViewer[n];
       } else {
         p = new((void*) gvp) TEveViewer[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveViewer;
       } else {
         p = new((void*) gvp) TEveViewer;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_416_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveViewer*) G__getstructoffset())->GetGLViewer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_416_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewer*) G__getstructoffset())->SetGLViewer((TGLViewer*) G__int(libp->para[0]), (TGFrame*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_416_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TEveViewer*) G__getstructoffset())->SpawnGLViewer((TGedEditor*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TEveViewer*) G__getstructoffset())->SpawnGLViewer((TGedEditor*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TEveViewer*) G__getstructoffset())->SpawnGLViewer());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_416_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TEveViewer*) G__getstructoffset())->SpawnGLEmbeddedViewer((TGedEditor*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TEveViewer*) G__getstructoffset())->SpawnGLEmbeddedViewer((TGedEditor*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TEveViewer*) G__getstructoffset())->SpawnGLEmbeddedViewer());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_416_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveViewer*) G__getstructoffset())->Redraw((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveViewer*) G__getstructoffset())->Redraw();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_416_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewer*) G__getstructoffset())->SwitchStereo();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_416_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewer*) G__getstructoffset())->AddScene((TEveScene*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_416_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TEveViewer*) G__getstructoffset())->GetEditorObject(*(TEveException*) libp->para[0].ref));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TEveViewer*) G__getstructoffset())->GetEditorObject());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_416_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveViewer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_416_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveViewer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_416_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveViewer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_416_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveViewer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_416_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_416_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveViewer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_416_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveViewer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_416_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveViewer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_416_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveViewer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveViewer G__TTEveViewer;
static int G__G__Eve1_416_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveViewer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveViewer*) (soff+(sizeof(TEveViewer)*i)))->~G__TTEveViewer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveViewer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveViewer*) (soff))->~G__TTEveViewer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveViewerList */
static int G__G__Eve1_417_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveViewerList* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveViewerList((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveViewerList((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveViewerList((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveViewerList((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveViewerList[n];
       } else {
         p = new((void*) gvp) TEveViewerList[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveViewerList;
       } else {
         p = new((void*) gvp) TEveViewerList;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerList));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerList*) G__getstructoffset())->Connect();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerList*) G__getstructoffset())->Disconnect();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerList*) G__getstructoffset())->RepaintChangedViewers((Bool_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__Eve1_417_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerList*) G__getstructoffset())->RepaintAllViewers((Bool_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__Eve1_417_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerList*) G__getstructoffset())->DeleteAnnotations();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerList*) G__getstructoffset())->SceneDestructing((TEveScene*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerList*) G__getstructoffset())->OnMouseOver((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__Eve1_417_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerList*) G__getstructoffset())->OnReMouseOver((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__Eve1_417_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerList*) G__getstructoffset())->OnUnMouseOver((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__Eve1_417_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerList*) G__getstructoffset())->OnClicked((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__Eve1_417_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerList*) G__getstructoffset())->OnReClicked((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__Eve1_417_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerList*) G__getstructoffset())->OnUnClicked((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__Eve1_417_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveViewerList*) G__getstructoffset())->GetShowTooltip());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerList*) G__getstructoffset())->SetShowTooltip((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveViewerList*) G__getstructoffset())->GetColorBrightness());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerList*) G__getstructoffset())->SetColorBrightness((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveViewerList*) G__getstructoffset())->UseLightColorSet());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerList*) G__getstructoffset())->SwitchColorSet();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveViewerList::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveViewerList::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveViewerList::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveViewerList::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerList*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveViewerList::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveViewerList::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveViewerList::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_417_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveViewerList::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveViewerList G__TTEveViewerList;
static int G__G__Eve1_417_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[] (TEveViewerList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveViewerList*) (soff+(sizeof(TEveViewerList)*i)))->~G__TTEveViewerList();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveViewerList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveViewerList*) (soff))->~G__TTEveViewerList();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveScene */
static int G__G__Eve1_418_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveScene* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveScene((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveScene((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveScene((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveScene((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveScene[n];
       } else {
         p = new((void*) gvp) TEveScene[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveScene;
       } else {
         p = new((void*) gvp) TEveScene;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveScene));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveScene*) G__getstructoffset())->Changed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveScene*) G__getstructoffset())->IsChanged());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveScene*) G__getstructoffset())->SetHierarchical((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveScene*) G__getstructoffset())->GetHierarchical());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveScene*) G__getstructoffset())->Repaint((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveScene*) G__getstructoffset())->Repaint();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveScene*) G__getstructoffset())->RetransHierarchically();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveScene*) G__getstructoffset())->GetGLScene());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveScene*) G__getstructoffset())->SetGLScene((TGLScenePad*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveScene*) G__getstructoffset())->DestroyElementRenderers((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveScene*) G__getstructoffset())->DestroyElementRenderers((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveScene::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveScene::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveScene::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveScene::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveScene*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveScene::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveScene::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveScene::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_418_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveScene::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveScene G__TTEveScene;
static int G__G__Eve1_418_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveScene*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveScene*) (soff+(sizeof(TEveScene)*i)))->~G__TTEveScene();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveScene*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveScene*) (soff))->~G__TTEveScene();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveSceneList */
static int G__G__Eve1_419_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveSceneList* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveSceneList((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveSceneList((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveSceneList((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveSceneList((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveSceneList[n];
       } else {
         p = new((void*) gvp) TEveSceneList[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveSceneList;
       } else {
         p = new((void*) gvp) TEveSceneList;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneList));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_419_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSceneList*) G__getstructoffset())->DestroyScenes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_419_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSceneList*) G__getstructoffset())->RepaintChangedScenes((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_419_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSceneList*) G__getstructoffset())->RepaintAllScenes((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_419_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSceneList*) G__getstructoffset())->DestroyElementRenderers((TEveElement*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_419_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSceneList*) G__getstructoffset())->ProcessSceneChanges((Bool_t) G__int(libp->para[0]), (TExMap*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_419_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveSceneList::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_419_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveSceneList::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_419_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveSceneList::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_419_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveSceneList::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_419_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSceneList*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_419_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveSceneList::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_419_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveSceneList::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_419_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveSceneList::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_419_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveSceneList::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveSceneList G__TTEveSceneList;
static int G__G__Eve1_419_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveSceneList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveSceneList*) (soff+(sizeof(TEveSceneList)*i)))->~G__TTEveSceneList();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveSceneList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveSceneList*) (soff))->~G__TTEveSceneList();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveWindowManager */
static int G__G__Eve1_420_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveWindowManager* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveWindowManager((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveWindowManager((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveWindowManager((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveWindowManager((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveWindowManager[n];
       } else {
         p = new((void*) gvp) TEveWindowManager[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveWindowManager;
       } else {
         p = new((void*) gvp) TEveWindowManager;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowManager));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowManager*) G__getstructoffset())->SelectWindow((TEveWindow*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowManager*) G__getstructoffset())->DeleteWindow((TEveWindow*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowManager*) G__getstructoffset())->WindowDocked((TEveWindow*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowManager*) G__getstructoffset())->WindowUndocked((TEveWindow*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowManager*) G__getstructoffset())->WindowSelected((TEveWindow*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowManager*) G__getstructoffset())->WindowDeleted((TEveWindow*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveWindowManager*) G__getstructoffset())->GetCurrentWindow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveWindowManager*) G__getstructoffset())->IsCurrentWindow((TEveWindow*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveWindowManager*) G__getstructoffset())->GetCurrentWindowAsSlot());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveWindowManager*) G__getstructoffset())->GetDefaultContainer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveWindowManager*) G__getstructoffset())->HasDefaultContainer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowManager*) G__getstructoffset())->SetDefaultContainer((TEveWindow*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowManager*) G__getstructoffset())->DestroyWindows();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowManager*) G__getstructoffset())->HideAllEveDecorations();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowManager*) G__getstructoffset())->ShowNormalEveDecorations();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowManager*) G__getstructoffset())->SetShowTitleBars((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveWindowManager::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowManager::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveWindowManager::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveWindowManager::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowManager::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveWindowManager::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowManager::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_420_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveWindowManager::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveWindowManager G__TTEveWindowManager;
static int G__G__Eve1_420_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[] (TEveWindowManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveWindowManager*) (soff+(sizeof(TEveWindowManager)*i)))->~G__TTEveWindowManager();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveWindowManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveWindowManager*) (soff))->~G__TTEveWindowManager();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveManager::TRedrawDisabler */
static int G__G__Eve1_421_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveManager::TRedrawDisabler* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveManager::TRedrawDisabler((TEveManager*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveManager::TRedrawDisabler((TEveManager*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveManagercLcLTRedrawDisabler));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_421_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveManager::TRedrawDisabler::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_421_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveManager::TRedrawDisabler::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_421_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveManager::TRedrawDisabler::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_421_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveManager::TRedrawDisabler::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_421_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveManager::TRedrawDisabler*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_421_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager::TRedrawDisabler*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_421_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager::TRedrawDisabler*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_421_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager::TRedrawDisabler*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_421_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveManager::TRedrawDisabler::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_421_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveManager::TRedrawDisabler::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_421_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveManager::TRedrawDisabler::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_421_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveManager::TRedrawDisabler::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveManager::TRedrawDisabler G__TTEveManagercLcLTRedrawDisabler;
static int G__G__Eve1_421_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[] (TEveManager::TRedrawDisabler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveManager::TRedrawDisabler*) (soff+(sizeof(TEveManager::TRedrawDisabler)*i)))->~G__TTEveManagercLcLTRedrawDisabler();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveManager::TRedrawDisabler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveManager::TRedrawDisabler*) (soff))->~G__TTEveManagercLcLTRedrawDisabler();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveManager::TExceptionHandler */
static int G__G__Eve1_422_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveManager::TExceptionHandler* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveManager::TExceptionHandler[n];
     } else {
       p = new((void*) gvp) TEveManager::TExceptionHandler[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveManager::TExceptionHandler;
     } else {
       p = new((void*) gvp) TEveManager::TExceptionHandler;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveManagercLcLTExceptionHandler));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_422_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveManager::TExceptionHandler::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_422_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveManager::TExceptionHandler::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_422_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveManager::TExceptionHandler::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_422_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveManager::TExceptionHandler::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_422_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveManager::TExceptionHandler*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_422_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveManager::TExceptionHandler::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_422_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveManager::TExceptionHandler::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_422_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveManager::TExceptionHandler::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_422_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveManager::TExceptionHandler::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveManager::TExceptionHandler G__TTEveManagercLcLTExceptionHandler;
static int G__G__Eve1_422_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveManager::TExceptionHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveManager::TExceptionHandler*) (soff+(sizeof(TEveManager::TExceptionHandler)*i)))->~G__TTEveManagercLcLTExceptionHandler();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveManager::TExceptionHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveManager::TExceptionHandler*) (soff))->~G__TTEveManagercLcLTExceptionHandler();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvePad */
static int G__G__Eve1_427_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePad* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePad[n];
     } else {
       p = new((void*) gvp) TEvePad[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePad;
     } else {
       p = new((void*) gvp) TEvePad;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEvePad));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_427_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePad* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePad(
(const char*) G__int(libp->para[0]), (const char*) 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])
, (Color_t) G__int(libp->para[6]), (Short_t) G__int(libp->para[7])
, (Short_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TEvePad(
(const char*) G__int(libp->para[0]), (const char*) 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])
, (Color_t) G__int(libp->para[6]), (Short_t) G__int(libp->para[7])
, (Short_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePad(
(const char*) G__int(libp->para[0]), (const char*) 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])
, (Color_t) G__int(libp->para[6]), (Short_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TEvePad(
(const char*) G__int(libp->para[0]), (const char*) 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])
, (Color_t) G__int(libp->para[6]), (Short_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePad(
(const char*) G__int(libp->para[0]), (const char*) 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])
, (Color_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TEvePad(
(const char*) G__int(libp->para[0]), (const char*) 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])
, (Color_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePad(
(const char*) G__int(libp->para[0]), (const char*) 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) TEvePad(
(const char*) G__int(libp->para[0]), (const char*) 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]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEvePad));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_427_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvePad::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_427_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePad::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_427_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvePad::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_427_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvePad::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_427_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePad*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_427_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePad::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_427_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePad::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_427_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePad::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_427_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePad::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvePad G__TTEvePad;
static int G__G__Eve1_427_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[] (TEvePad*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvePad*) (soff+(sizeof(TEvePad)*i)))->~G__TTEvePad();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvePad*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvePad*) (soff))->~G__TTEvePad();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveParamList */
static int G__G__Eve1_428_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveParamList* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveParamList(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveParamList(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveParamList((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveParamList((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveParamList((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveParamList((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveParamList[n];
       } else {
         p = new((void*) gvp) TEveParamList[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveParamList;
       } else {
         p = new((void*) gvp) TEveParamList;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_428_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveParamList*) G__getstructoffset())->AddParameter(*(TEveParamList::FloatConfig_t*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_428_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveParamList*) G__getstructoffset())->AddParameter(*(TEveParamList::IntConfig_t*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_428_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveParamList*) G__getstructoffset())->AddParameter(*(TEveParamList::BoolConfig_t*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_428_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveParamList::FloatConfigVec_t& obj = ((TEveParamList*) G__getstructoffset())->GetFloatParameters();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_428_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveParamList::IntConfigVec_t& obj = ((TEveParamList*) G__getstructoffset())->GetIntParameters();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_428_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveParamList::BoolConfigVec_t& obj = ((TEveParamList*) G__getstructoffset())->GetBoolParameters();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_428_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveParamList::FloatConfig_t* pobj;
         TEveParamList::FloatConfig_t xobj = ((TEveParamList*) G__getstructoffset())->GetFloatParameter(*(TString*) libp->para[0].ref);
         pobj = new TEveParamList::FloatConfig_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__Eve1_428_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveParamList::IntConfig_t* pobj;
         TEveParamList::IntConfig_t xobj = ((TEveParamList*) G__getstructoffset())->GetIntParameter(*(TString*) libp->para[0].ref);
         pobj = new TEveParamList::IntConfig_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__Eve1_428_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveParamList*) G__getstructoffset())->GetBoolParameter(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_428_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveParamList*) G__getstructoffset())->ParamChanged((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_428_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveParamList::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_428_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveParamList::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_428_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveParamList::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_428_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveParamList::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_428_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveParamList*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_428_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveParamList::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_428_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveParamList::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_428_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveParamList::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_428_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveParamList::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveParamList G__TTEveParamList;
static int G__G__Eve1_428_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[] (TEveParamList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveParamList*) (soff+(sizeof(TEveParamList)*i)))->~G__TTEveParamList();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveParamList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveParamList*) (soff))->~G__TTEveParamList();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveParamListEditor */
static int G__G__Eve1_429_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveParamListEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveParamListEditor(
(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) TEveParamListEditor(
(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 TEveParamListEditor(
(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) TEveParamListEditor(
(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 TEveParamListEditor(
(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) TEveParamListEditor(
(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 TEveParamListEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveParamListEditor((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 TEveParamListEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveParamListEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveParamListEditor[n];
       } else {
         p = new((void*) gvp) TEveParamListEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveParamListEditor;
       } else {
         p = new((void*) gvp) TEveParamListEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_429_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveParamListEditor*) G__getstructoffset())->DoIntUpdate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_429_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveParamListEditor*) G__getstructoffset())->DoFloatUpdate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_429_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveParamListEditor*) G__getstructoffset())->DoBoolUpdate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_429_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveParamListEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_429_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveParamListEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_429_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveParamListEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_429_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveParamListEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_429_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveParamListEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_429_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveParamListEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_429_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveParamListEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_429_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveParamListEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_429_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveParamListEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveParamListEditor G__TTEveParamListEditor;
static int G__G__Eve1_429_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveParamListEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveParamListEditor*) (soff+(sizeof(TEveParamListEditor)*i)))->~G__TTEveParamListEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveParamListEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveParamListEditor*) (soff))->~G__TTEveParamListEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveParamList::FloatConfig_t */
static int G__G__Eve1_430_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveParamList::FloatConfig_t* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveParamList::FloatConfig_t(
*((TString*) 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])
, (Bool_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TEveParamList::FloatConfig_t(
*((TString*) 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])
, (Bool_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveParamList::FloatConfig_t(
*((TString*) 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]));
     } else {
       p = new((void*) gvp) TEveParamList::FloatConfig_t(
*((TString*) 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]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLFloatConfig_t));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_430_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveParamList::FloatConfig_t* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveParamList::FloatConfig_t[n];
     } else {
       p = new((void*) gvp) TEveParamList::FloatConfig_t[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveParamList::FloatConfig_t;
     } else {
       p = new((void*) gvp) TEveParamList::FloatConfig_t;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLFloatConfig_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_430_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveParamList::FloatConfig_t* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveParamList::FloatConfig_t(*(TEveParamList::FloatConfig_t*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLFloatConfig_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveParamList::FloatConfig_t G__TTEveParamListcLcLFloatConfig_t;
static int G__G__Eve1_430_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveParamList::FloatConfig_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveParamList::FloatConfig_t*) (soff+(sizeof(TEveParamList::FloatConfig_t)*i)))->~G__TTEveParamListcLcLFloatConfig_t();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveParamList::FloatConfig_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveParamList::FloatConfig_t*) (soff))->~G__TTEveParamListcLcLFloatConfig_t();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_430_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveParamList::FloatConfig_t* dest = (TEveParamList::FloatConfig_t*) G__getstructoffset();
   *dest = *(TEveParamList::FloatConfig_t*) libp->para[0].ref;
   const TEveParamList::FloatConfig_t& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveParamList::IntConfig_t */
static int G__G__Eve1_435_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveParamList::IntConfig_t* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveParamList::IntConfig_t(
*((TString*) 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])
, (Bool_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TEveParamList::IntConfig_t(
*((TString*) 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])
, (Bool_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveParamList::IntConfig_t(
*((TString*) 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) TEveParamList::IntConfig_t(
*((TString*) 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;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLIntConfig_t));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_435_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveParamList::IntConfig_t* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveParamList::IntConfig_t[n];
     } else {
       p = new((void*) gvp) TEveParamList::IntConfig_t[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveParamList::IntConfig_t;
     } else {
       p = new((void*) gvp) TEveParamList::IntConfig_t;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLIntConfig_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_435_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveParamList::IntConfig_t* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveParamList::IntConfig_t(*(TEveParamList::IntConfig_t*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLIntConfig_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveParamList::IntConfig_t G__TTEveParamListcLcLIntConfig_t;
static int G__G__Eve1_435_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveParamList::IntConfig_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveParamList::IntConfig_t*) (soff+(sizeof(TEveParamList::IntConfig_t)*i)))->~G__TTEveParamListcLcLIntConfig_t();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveParamList::IntConfig_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveParamList::IntConfig_t*) (soff))->~G__TTEveParamListcLcLIntConfig_t();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_435_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveParamList::IntConfig_t* dest = (TEveParamList::IntConfig_t*) G__getstructoffset();
   *dest = *(TEveParamList::IntConfig_t*) libp->para[0].ref;
   const TEveParamList::IntConfig_t& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveParamList::BoolConfig_t */
static int G__G__Eve1_440_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveParamList::BoolConfig_t* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveParamList::BoolConfig_t(*((TString*) G__int(libp->para[0])), (Bool_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TEveParamList::BoolConfig_t(*((TString*) G__int(libp->para[0])), (Bool_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLBoolConfig_t));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_440_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveParamList::BoolConfig_t* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveParamList::BoolConfig_t[n];
     } else {
       p = new((void*) gvp) TEveParamList::BoolConfig_t[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveParamList::BoolConfig_t;
     } else {
       p = new((void*) gvp) TEveParamList::BoolConfig_t;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLBoolConfig_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_440_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveParamList::BoolConfig_t* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveParamList::BoolConfig_t(*(TEveParamList::BoolConfig_t*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLBoolConfig_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveParamList::BoolConfig_t G__TTEveParamListcLcLBoolConfig_t;
static int G__G__Eve1_440_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveParamList::BoolConfig_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveParamList::BoolConfig_t*) (soff+(sizeof(TEveParamList::BoolConfig_t)*i)))->~G__TTEveParamListcLcLBoolConfig_t();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveParamList::BoolConfig_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveParamList::BoolConfig_t*) (soff))->~G__TTEveParamListcLcLBoolConfig_t();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_440_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveParamList::BoolConfig_t* dest = (TEveParamList::BoolConfig_t*) G__getstructoffset();
   *dest = *(TEveParamList::BoolConfig_t*) libp->para[0].ref;
   const TEveParamList::BoolConfig_t& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveProjectionAxes */
static int G__G__Eve1_454_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveProjectionAxes* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveProjectionAxes((TEveProjectionManager*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveProjectionAxes((TEveProjectionManager*) 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 TEveProjectionAxes((TEveProjectionManager*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveProjectionAxes((TEveProjectionManager*) 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__Eve1LN_TEveProjectionAxes));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveProjectionAxes*) G__getstructoffset())->GetManager());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionAxes*) G__getstructoffset())->SetLabMode((TEveProjectionAxes::ELabMode) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveProjectionAxes*) G__getstructoffset())->GetLabMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionAxes*) G__getstructoffset())->SetAxesMode((TEveProjectionAxes::EAxesMode) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveProjectionAxes*) G__getstructoffset())->GetAxesMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionAxes*) G__getstructoffset())->SetDrawCenter((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveProjectionAxes*) G__getstructoffset())->GetDrawCenter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionAxes*) G__getstructoffset())->SetDrawOrigin((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveProjectionAxes*) G__getstructoffset())->GetDrawOrigin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveProjectionAxes::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectionAxes::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveProjectionAxes::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveProjectionAxes::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionAxes*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectionAxes::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjectionAxes::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectionAxes::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_454_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjectionAxes::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveProjectionAxes G__TTEveProjectionAxes;
static int G__G__Eve1_454_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[] (TEveProjectionAxes*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveProjectionAxes*) (soff+(sizeof(TEveProjectionAxes)*i)))->~G__TTEveProjectionAxes();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveProjectionAxes*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveProjectionAxes*) (soff))->~G__TTEveProjectionAxes();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveProjectionAxesEditor */
static int G__G__Eve1_455_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveProjectionAxesEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveProjectionAxesEditor(
(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) TEveProjectionAxesEditor(
(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 TEveProjectionAxesEditor(
(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) TEveProjectionAxesEditor(
(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 TEveProjectionAxesEditor(
(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) TEveProjectionAxesEditor(
(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 TEveProjectionAxesEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveProjectionAxesEditor((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 TEveProjectionAxesEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveProjectionAxesEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveProjectionAxesEditor[n];
       } else {
         p = new((void*) gvp) TEveProjectionAxesEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveProjectionAxesEditor;
       } else {
         p = new((void*) gvp) TEveProjectionAxesEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_455_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionAxesEditor*) G__getstructoffset())->DoLabMode((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_455_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionAxesEditor*) G__getstructoffset())->DoAxesMode((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_455_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionAxesEditor*) G__getstructoffset())->DoDrawCenter();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_455_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionAxesEditor*) G__getstructoffset())->DoDrawOrigin();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_455_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveProjectionAxesEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_455_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectionAxesEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_455_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveProjectionAxesEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_455_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveProjectionAxesEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_455_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionAxesEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_455_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectionAxesEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_455_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjectionAxesEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_455_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectionAxesEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_455_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjectionAxesEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveProjectionAxesEditor G__TTEveProjectionAxesEditor;
static int G__G__Eve1_455_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveProjectionAxesEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveProjectionAxesEditor*) (soff+(sizeof(TEveProjectionAxesEditor)*i)))->~G__TTEveProjectionAxesEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveProjectionAxesEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveProjectionAxesEditor*) (soff))->~G__TTEveProjectionAxesEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveProjectionAxesGL */
static int G__G__Eve1_566_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveProjectionAxesGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveProjectionAxesGL[n];
     } else {
       p = new((void*) gvp) TEveProjectionAxesGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveProjectionAxesGL;
     } else {
       p = new((void*) gvp) TEveProjectionAxesGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_566_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveProjectionAxesGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_566_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectionAxesGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_566_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveProjectionAxesGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_566_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveProjectionAxesGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_566_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionAxesGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_566_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectionAxesGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_566_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjectionAxesGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_566_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectionAxesGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_566_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjectionAxesGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveProjectionAxesGL G__TTEveProjectionAxesGL;
static int G__G__Eve1_566_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[] (TEveProjectionAxesGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveProjectionAxesGL*) (soff+(sizeof(TEveProjectionAxesGL)*i)))->~G__TTEveProjectionAxesGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveProjectionAxesGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveProjectionAxesGL*) (soff))->~G__TTEveProjectionAxesGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveProjectionManagerEditor */
static int G__G__Eve1_571_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveProjectionManagerEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveProjectionManagerEditor(
(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) TEveProjectionManagerEditor(
(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 TEveProjectionManagerEditor(
(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) TEveProjectionManagerEditor(
(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 TEveProjectionManagerEditor(
(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) TEveProjectionManagerEditor(
(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 TEveProjectionManagerEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveProjectionManagerEditor((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 TEveProjectionManagerEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveProjectionManagerEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveProjectionManagerEditor[n];
       } else {
         p = new((void*) gvp) TEveProjectionManagerEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveProjectionManagerEditor;
       } else {
         p = new((void*) gvp) TEveProjectionManagerEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManagerEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManagerEditor*) G__getstructoffset())->DoType((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManagerEditor*) G__getstructoffset())->DoDistortion();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManagerEditor*) G__getstructoffset())->DoFixR();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManagerEditor*) G__getstructoffset())->DoFixZ();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManagerEditor*) G__getstructoffset())->DoPastFixRFac();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManagerEditor*) G__getstructoffset())->DoPastFixZFac();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManagerEditor*) G__getstructoffset())->DoCurrentDepth();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManagerEditor*) G__getstructoffset())->DoMaxTrackStep();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManagerEditor*) G__getstructoffset())->DoCenter();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveProjectionManagerEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectionManagerEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveProjectionManagerEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveProjectionManagerEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjectionManagerEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectionManagerEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjectionManagerEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjectionManagerEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_571_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjectionManagerEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveProjectionManagerEditor G__TTEveProjectionManagerEditor;
static int G__G__Eve1_571_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[] (TEveProjectionManagerEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveProjectionManagerEditor*) (soff+(sizeof(TEveProjectionManagerEditor)*i)))->~G__TTEveProjectionManagerEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveProjectionManagerEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveProjectionManagerEditor*) (soff))->~G__TTEveProjectionManagerEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveVectorT<float> */
static int G__G__Eve1_573_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVectorT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVectorT<float>[n];
     } else {
       p = new((void*) gvp) TEveVectorT<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVectorT<float>;
     } else {
       p = new((void*) gvp) TEveVectorT<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVectorT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVectorT<float>((Float_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveVectorT<float>((Float_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__Eve1LN_TEveVectorTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVectorT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVectorT<float>((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveVectorT<float>((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__Eve1LN_TEveVectorTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVectorT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVectorT<float>(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) TEveVectorT<float>(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveVectorT<float>*) G__getstructoffset())->Dump();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TEveVectorT<float>*) G__getstructoffset())->operator const float*());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((TEveVectorT<float>*) G__getstructoffset())->operator float*());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVectorT<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TEveVectorT<float>*) 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__Eve1_573_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TEveVectorT<float>*) G__getstructoffset())->Arr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((TEveVectorT<float>*) G__getstructoffset())->Arr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVectorT<float>& obj = ((TEveVectorT<float>*) G__getstructoffset())->operator*=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVectorT<float>& obj = ((TEveVectorT<float>*) G__getstructoffset())->operator+=(*(TEveVectorT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVectorT<float>& obj = ((TEveVectorT<float>*) G__getstructoffset())->operator-=(*(TEveVectorT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVectorT<float>*) G__getstructoffset())->Set((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVectorT<float>*) G__getstructoffset())->Set((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVectorT<float>*) G__getstructoffset())->Set((float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVectorT<float>*) G__getstructoffset())->Set(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVectorT<float>*) G__getstructoffset())->NegateXYZ();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 102, (double) ((TEveVectorT<float>*) G__getstructoffset())->Normalize((float) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 102, (double) ((TEveVectorT<float>*) G__getstructoffset())->Normalize());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVectorT<float>*) G__getstructoffset())->Phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVectorT<float>*) G__getstructoffset())->Theta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVectorT<float>*) G__getstructoffset())->CosTheta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVectorT<float>*) G__getstructoffset())->Eta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVectorT<float>*) G__getstructoffset())->Mag2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVectorT<float>*) G__getstructoffset())->Mag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVectorT<float>*) G__getstructoffset())->Perp2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVectorT<float>*) G__getstructoffset())->Perp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVectorT<float>*) G__getstructoffset())->R());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVectorT<float>*) G__getstructoffset())->Distance(*(TEveVectorT<float>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVectorT<float>*) G__getstructoffset())->SquareDistance(*(TEveVectorT<float>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVectorT<float>*) G__getstructoffset())->Dot(*(TEveVectorT<float>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVectorT<float>* pobj;
         const TEveVectorT<float> xobj = ((const TEveVectorT<float>*) G__getstructoffset())->Cross(*(TEveVectorT<float>*) libp->para[0].ref);
         pobj = new TEveVectorT<float>(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__Eve1_573_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVectorT<float>& obj = ((TEveVectorT<float>*) G__getstructoffset())->Sub(*(TEveVectorT<float>*) libp->para[0].ref, *(TEveVectorT<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVectorT<float>& obj = ((TEveVectorT<float>*) G__getstructoffset())->Mult(*(TEveVectorT<float>*) libp->para[0].ref, (float) G__double(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVectorT<float>* pobj;
         const TEveVectorT<float> xobj = ((const TEveVectorT<float>*) G__getstructoffset())->Orthogonal();
         pobj = new TEveVectorT<float>(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__Eve1_573_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveVectorT<float>*) G__getstructoffset())->OrthoNormBase(*(TEveVectorT<float>*) libp->para[0].ref, *(TEveVectorT<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveVectorT<float>*) G__getstructoffset())->IsZero());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveVectorT<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVectorT<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveVectorT<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveVectorT<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveVectorT<float>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVectorT<float>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVectorT<float>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVectorT<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVectorT<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveVectorT<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVectorT<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveVectorT<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_573_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVectorT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVectorT<float>(*(TEveVectorT<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEveVectorT<float>(*(TEveVectorT<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_573_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveVectorT<float>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveVectorT<float>(*(TEveVectorT<float>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveVectorT<float> G__TTEveVectorTlEfloatgR;
static int G__G__Eve1_573_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[] (TEveVectorT<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveVectorT<float>*) (soff+(sizeof(TEveVectorT<float>)*i)))->~G__TTEveVectorTlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveVectorT<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveVectorT<float>*) (soff))->~G__TTEveVectorTlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_573_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVectorT<float>* dest = (TEveVectorT<float>*) G__getstructoffset();
   *dest = *(TEveVectorT<float>*) libp->para[0].ref;
   const TEveVectorT<float>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveVectorT<double> */
static int G__G__Eve1_574_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVectorT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVectorT<double>[n];
     } else {
       p = new((void*) gvp) TEveVectorT<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVectorT<double>;
     } else {
       p = new((void*) gvp) TEveVectorT<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVectorT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVectorT<double>((Float_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveVectorT<double>((Float_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__Eve1LN_TEveVectorTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVectorT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVectorT<double>((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveVectorT<double>((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__Eve1LN_TEveVectorTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVectorT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVectorT<double>(
(double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) TEveVectorT<double>(
(double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveVectorT<double>*) G__getstructoffset())->Dump();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TEveVectorT<double>*) G__getstructoffset())->operator const double*());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TEveVectorT<double>*) G__getstructoffset())->operator double*());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVectorT<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TEveVectorT<double>*) 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__Eve1_574_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TEveVectorT<double>*) G__getstructoffset())->Arr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TEveVectorT<double>*) G__getstructoffset())->Arr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVectorT<double>& obj = ((TEveVectorT<double>*) G__getstructoffset())->operator*=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVectorT<double>& obj = ((TEveVectorT<double>*) G__getstructoffset())->operator+=(*(TEveVectorT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVectorT<double>& obj = ((TEveVectorT<double>*) G__getstructoffset())->operator-=(*(TEveVectorT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVectorT<double>*) G__getstructoffset())->Set((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVectorT<double>*) G__getstructoffset())->Set((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVectorT<double>*) G__getstructoffset())->Set((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVectorT<double>*) G__getstructoffset())->Set(*(TVector3*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVectorT<double>*) G__getstructoffset())->NegateXYZ();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((TEveVectorT<double>*) G__getstructoffset())->Normalize((double) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((TEveVectorT<double>*) G__getstructoffset())->Normalize());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVectorT<double>*) G__getstructoffset())->Phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVectorT<double>*) G__getstructoffset())->Theta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVectorT<double>*) G__getstructoffset())->CosTheta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVectorT<double>*) G__getstructoffset())->Eta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVectorT<double>*) G__getstructoffset())->Mag2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVectorT<double>*) G__getstructoffset())->Mag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVectorT<double>*) G__getstructoffset())->Perp2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVectorT<double>*) G__getstructoffset())->Perp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVectorT<double>*) G__getstructoffset())->R());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVectorT<double>*) G__getstructoffset())->Distance(*(TEveVectorT<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVectorT<double>*) G__getstructoffset())->SquareDistance(*(TEveVectorT<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVectorT<double>*) G__getstructoffset())->Dot(*(TEveVectorT<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVectorT<double>* pobj;
         const TEveVectorT<double> xobj = ((const TEveVectorT<double>*) G__getstructoffset())->Cross(*(TEveVectorT<double>*) libp->para[0].ref);
         pobj = new TEveVectorT<double>(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__Eve1_574_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVectorT<double>& obj = ((TEveVectorT<double>*) G__getstructoffset())->Sub(*(TEveVectorT<double>*) libp->para[0].ref, *(TEveVectorT<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVectorT<double>& obj = ((TEveVectorT<double>*) G__getstructoffset())->Mult(*(TEveVectorT<double>*) libp->para[0].ref, (double) G__double(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVectorT<double>* pobj;
         const TEveVectorT<double> xobj = ((const TEveVectorT<double>*) G__getstructoffset())->Orthogonal();
         pobj = new TEveVectorT<double>(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__Eve1_574_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveVectorT<double>*) G__getstructoffset())->OrthoNormBase(*(TEveVectorT<double>*) libp->para[0].ref, *(TEveVectorT<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveVectorT<double>*) G__getstructoffset())->IsZero());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveVectorT<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVectorT<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveVectorT<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveVectorT<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveVectorT<double>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVectorT<double>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVectorT<double>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVectorT<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVectorT<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveVectorT<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVectorT<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_574_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveVectorT<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_574_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveVectorT<double>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveVectorT<double>(*(TEveVectorT<double>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveVectorT<double> G__TTEveVectorTlEdoublegR;
static int G__G__Eve1_574_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveVectorT<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveVectorT<double>*) (soff+(sizeof(TEveVectorT<double>)*i)))->~G__TTEveVectorTlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveVectorT<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveVectorT<double>*) (soff))->~G__TTEveVectorTlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_574_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVectorT<double>* dest = (TEveVectorT<double>*) G__getstructoffset();
   *dest = *(TEveVectorT<double>*) libp->para[0].ref;
   const TEveVectorT<double>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveVector4T<float> */
static int G__G__Eve1_575_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector4T<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVector4T<float>[n];
     } else {
       p = new((void*) gvp) TEveVector4T<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVector4T<float>;
     } else {
       p = new((void*) gvp) TEveVector4T<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector4T<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVector4T<float>((Float_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveVector4T<float>((Float_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__Eve1LN_TEveVector4TlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector4T<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVector4T<float>((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveVector4T<float>((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__Eve1LN_TEveVector4TlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector4T<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVector4T<float>(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]), (float) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TEveVector4T<float>(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]), (float) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVector4T<float>(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveVector4T<float>(
(float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, (float) 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__Eve1LN_TEveVector4TlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveVector4T<float>*) G__getstructoffset())->Dump();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector4T<float>& obj = ((TEveVector4T<float>*) G__getstructoffset())->operator*=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector4T<float>& obj = ((TEveVector4T<float>*) G__getstructoffset())->operator+=(*(TEveVector4T<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector4T<float>& obj = ((TEveVector4T<float>*) G__getstructoffset())->operator-=(*(TEveVector4T<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveVector4T<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVector4T<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveVector4T<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveVector4T<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveVector4T<float>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector4T<float>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector4T<float>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector4T<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVector4T<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveVector4T<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVector4T<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveVector4T<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector4T<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVector4T<float>(*(TEveVectorT<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEveVector4T<float>(*(TEveVectorT<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_575_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector4T<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVector4T<float>(*(TEveVector4T<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEveVector4T<float>(*(TEveVector4T<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_575_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveVector4T<float>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveVector4T<float>(*(TEveVector4T<float>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveVector4T<float> G__TTEveVector4TlEfloatgR;
static int G__G__Eve1_575_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[] (TEveVector4T<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveVector4T<float>*) (soff+(sizeof(TEveVector4T<float>)*i)))->~G__TTEveVector4TlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveVector4T<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveVector4T<float>*) (soff))->~G__TTEveVector4TlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_575_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector4T<float>* dest = (TEveVector4T<float>*) G__getstructoffset();
   *dest = *(TEveVector4T<float>*) libp->para[0].ref;
   const TEveVector4T<float>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveVector4T<double> */
static int G__G__Eve1_576_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector4T<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVector4T<double>[n];
     } else {
       p = new((void*) gvp) TEveVector4T<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVector4T<double>;
     } else {
       p = new((void*) gvp) TEveVector4T<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector4T<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVector4T<double>((Float_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveVector4T<double>((Float_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__Eve1LN_TEveVector4TlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector4T<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVector4T<double>((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveVector4T<double>((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__Eve1LN_TEveVector4TlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector4T<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVector4T<double>(
(double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TEveVector4T<double>(
(double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVector4T<double>(
(double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveVector4T<double>(
(double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, (double) 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__Eve1LN_TEveVector4TlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveVector4T<double>*) G__getstructoffset())->Dump();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector4T<double>& obj = ((TEveVector4T<double>*) G__getstructoffset())->operator*=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector4T<double>& obj = ((TEveVector4T<double>*) G__getstructoffset())->operator+=(*(TEveVector4T<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector4T<double>& obj = ((TEveVector4T<double>*) G__getstructoffset())->operator-=(*(TEveVector4T<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveVector4T<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVector4T<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveVector4T<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveVector4T<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveVector4T<double>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector4T<double>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector4T<double>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector4T<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVector4T<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveVector4T<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVector4T<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_576_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveVector4T<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_576_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveVector4T<double>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveVector4T<double>(*(TEveVector4T<double>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveVector4T<double> G__TTEveVector4TlEdoublegR;
static int G__G__Eve1_576_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[] (TEveVector4T<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveVector4T<double>*) (soff+(sizeof(TEveVector4T<double>)*i)))->~G__TTEveVector4TlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveVector4T<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveVector4T<double>*) (soff))->~G__TTEveVector4TlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_576_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector4T<double>* dest = (TEveVector4T<double>*) G__getstructoffset();
   *dest = *(TEveVector4T<double>*) libp->para[0].ref;
   const TEveVector4T<double>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveVector2T<float> */
static int G__G__Eve1_577_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector2T<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVector2T<float>[n];
     } else {
       p = new((void*) gvp) TEveVector2T<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVector2T<float>;
     } else {
       p = new((void*) gvp) TEveVector2T<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector2T<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVector2T<float>((Float_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveVector2T<float>((Float_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__Eve1LN_TEveVector2TlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector2T<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVector2T<float>((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveVector2T<float>((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__Eve1LN_TEveVector2TlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector2T<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVector2T<float>((float) G__double(libp->para[0]), (float) G__double(libp->para[1]));
   } else {
     p = new((void*) gvp) TEveVector2T<float>((float) G__double(libp->para[0]), (float) G__double(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveVector2T<float>*) G__getstructoffset())->Dump();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TEveVector2T<float>*) G__getstructoffset())->operator const float*());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((TEveVector2T<float>*) G__getstructoffset())->operator float*());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector2T<float>& obj = ((TEveVector2T<float>*) G__getstructoffset())->operator*=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector2T<float>& obj = ((TEveVector2T<float>*) G__getstructoffset())->operator+=(*(TEveVector2T<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector2T<float>& obj = ((TEveVector2T<float>*) G__getstructoffset())->operator-=(*(TEveVector2T<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TEveVector2T<float>*) 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__Eve1_577_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVector2T<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TEveVector2T<float>*) G__getstructoffset())->Arr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((TEveVector2T<float>*) G__getstructoffset())->Arr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector2T<float>*) G__getstructoffset())->Set((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector2T<float>*) G__getstructoffset())->Set((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector2T<float>*) G__getstructoffset())->Set((float) G__double(libp->para[0]), (float) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector2T<float>*) G__getstructoffset())->NegateXY();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveVector2T<float>*) G__getstructoffset())->Normalize((float) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveVector2T<float>*) G__getstructoffset())->Normalize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVector2T<float>*) G__getstructoffset())->Phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVector2T<float>*) G__getstructoffset())->Mag2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVector2T<float>*) G__getstructoffset())->Mag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVector2T<float>*) G__getstructoffset())->Distance(*(TEveVector2T<float>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVector2T<float>*) G__getstructoffset())->SquareDistance(*(TEveVector2T<float>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVector2T<float>*) G__getstructoffset())->Dot(*(TEveVector2T<float>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveVector2T<float>*) G__getstructoffset())->Cross(*(TEveVector2T<float>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector2T<float>& obj = ((TEveVector2T<float>*) G__getstructoffset())->Sub(*(TEveVector2T<float>*) libp->para[0].ref, *(TEveVector2T<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector2T<float>& obj = ((TEveVector2T<float>*) G__getstructoffset())->Mult(*(TEveVector2T<float>*) libp->para[0].ref, (float) G__double(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveVector2T<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVector2T<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveVector2T<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveVector2T<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveVector2T<float>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector2T<float>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector2T<float>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector2T<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVector2T<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveVector2T<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVector2T<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveVector2T<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_577_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector2T<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVector2T<float>(*(TEveVector2T<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEveVector2T<float>(*(TEveVector2T<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_577_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveVector2T<float>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveVector2T<float>(*(TEveVector2T<float>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveVector2T<float> G__TTEveVector2TlEfloatgR;
static int G__G__Eve1_577_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[] (TEveVector2T<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveVector2T<float>*) (soff+(sizeof(TEveVector2T<float>)*i)))->~G__TTEveVector2TlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveVector2T<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveVector2T<float>*) (soff))->~G__TTEveVector2TlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_577_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector2T<float>* dest = (TEveVector2T<float>*) G__getstructoffset();
   *dest = *(TEveVector2T<float>*) libp->para[0].ref;
   const TEveVector2T<float>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveVector2T<double> */
static int G__G__Eve1_578_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector2T<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVector2T<double>[n];
     } else {
       p = new((void*) gvp) TEveVector2T<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVector2T<double>;
     } else {
       p = new((void*) gvp) TEveVector2T<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector2T<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVector2T<double>((Float_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveVector2T<double>((Float_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__Eve1LN_TEveVector2TlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector2T<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVector2T<double>((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveVector2T<double>((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__Eve1LN_TEveVector2TlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector2T<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveVector2T<double>((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
   } else {
     p = new((void*) gvp) TEveVector2T<double>((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveVector2T<double>*) G__getstructoffset())->Dump();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TEveVector2T<double>*) G__getstructoffset())->operator const double*());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TEveVector2T<double>*) G__getstructoffset())->operator double*());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector2T<double>& obj = ((TEveVector2T<double>*) G__getstructoffset())->operator*=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector2T<double>& obj = ((TEveVector2T<double>*) G__getstructoffset())->operator+=(*(TEveVector2T<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector2T<double>& obj = ((TEveVector2T<double>*) G__getstructoffset())->operator-=(*(TEveVector2T<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TEveVector2T<double>*) 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__Eve1_578_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVector2T<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TEveVector2T<double>*) G__getstructoffset())->Arr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TEveVector2T<double>*) G__getstructoffset())->Arr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector2T<double>*) G__getstructoffset())->Set((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector2T<double>*) G__getstructoffset())->Set((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector2T<double>*) G__getstructoffset())->Set((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector2T<double>*) G__getstructoffset())->NegateXY();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveVector2T<double>*) G__getstructoffset())->Normalize((double) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveVector2T<double>*) G__getstructoffset())->Normalize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVector2T<double>*) G__getstructoffset())->Phi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVector2T<double>*) G__getstructoffset())->Mag2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVector2T<double>*) G__getstructoffset())->Mag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVector2T<double>*) G__getstructoffset())->Distance(*(TEveVector2T<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVector2T<double>*) G__getstructoffset())->SquareDistance(*(TEveVector2T<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVector2T<double>*) G__getstructoffset())->Dot(*(TEveVector2T<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveVector2T<double>*) G__getstructoffset())->Cross(*(TEveVector2T<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector2T<double>& obj = ((TEveVector2T<double>*) G__getstructoffset())->Sub(*(TEveVector2T<double>*) libp->para[0].ref, *(TEveVector2T<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector2T<double>& obj = ((TEveVector2T<double>*) G__getstructoffset())->Mult(*(TEveVector2T<double>*) libp->para[0].ref, (double) G__double(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveVector2T<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVector2T<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveVector2T<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveVector2T<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveVector2T<double>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector2T<double>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector2T<double>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVector2T<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVector2T<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveVector2T<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVector2T<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_578_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveVector2T<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_578_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveVector2T<double>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveVector2T<double>(*(TEveVector2T<double>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveVector2T<double> G__TTEveVector2TlEdoublegR;
static int G__G__Eve1_578_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveVector2T<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveVector2T<double>*) (soff+(sizeof(TEveVector2T<double>)*i)))->~G__TTEveVector2TlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveVector2T<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveVector2T<double>*) (soff))->~G__TTEveVector2TlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_578_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVector2T<double>* dest = (TEveVector2T<double>*) G__getstructoffset();
   *dest = *(TEveVector2T<double>*) libp->para[0].ref;
   const TEveVector2T<double>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveProjection::PreScaleEntry_t */
static int G__G__Eve1_582_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveProjection::PreScaleEntry_t* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveProjection::PreScaleEntry_t[n];
     } else {
       p = new((void*) gvp) TEveProjection::PreScaleEntry_t[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveProjection::PreScaleEntry_t;
     } else {
       p = new((void*) gvp) TEveProjection::PreScaleEntry_t;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_582_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveProjection::PreScaleEntry_t* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveProjection::PreScaleEntry_t(
(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) TEveProjection::PreScaleEntry_t(
(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]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_582_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveProjection::PreScaleEntry_t::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_582_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjection::PreScaleEntry_t::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_582_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveProjection::PreScaleEntry_t::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_582_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveProjection::PreScaleEntry_t::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_582_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveProjection::PreScaleEntry_t*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_582_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection::PreScaleEntry_t*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_582_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection::PreScaleEntry_t*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_582_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveProjection::PreScaleEntry_t*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_582_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjection::PreScaleEntry_t::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_582_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjection::PreScaleEntry_t::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_582_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveProjection::PreScaleEntry_t::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_582_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveProjection::PreScaleEntry_t::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_582_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveProjection::PreScaleEntry_t* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveProjection::PreScaleEntry_t(*(TEveProjection::PreScaleEntry_t*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveProjection::PreScaleEntry_t G__TTEveProjectioncLcLPreScaleEntry_t;
static int G__G__Eve1_582_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[] (TEveProjection::PreScaleEntry_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveProjection::PreScaleEntry_t*) (soff+(sizeof(TEveProjection::PreScaleEntry_t)*i)))->~G__TTEveProjectioncLcLPreScaleEntry_t();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveProjection::PreScaleEntry_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveProjection::PreScaleEntry_t*) (soff))->~G__TTEveProjectioncLcLPreScaleEntry_t();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_582_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveProjection::PreScaleEntry_t* dest = (TEveProjection::PreScaleEntry_t*) G__getstructoffset();
   *dest = *(TEveProjection::PreScaleEntry_t*) libp->para[0].ref;
   const TEveProjection::PreScaleEntry_t& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> > */
static int G__G__Eve1_584_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveProjection::PreScaleEntry_t& obj = ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->at((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator* pobj;
         vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator xobj = ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->begin();
         pobj = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator* pobj;
         vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator xobj = ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->end();
         pobj = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::reverse_iterator* pobj;
         vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::reverse_iterator xobj = ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->rbegin();
         pobj = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::reverse_iterator* pobj;
         vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::reverse_iterator xobj = ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->rend();
         pobj = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::reverse_iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->max_size());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->resize((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->resize((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type) G__int(libp->para[0]), *((TEveProjection::PreScaleEntry_t*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveProjection::PreScaleEntry_t& obj = ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->operator[]((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >[n];
     } else {
       p = new((void*) gvp) vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >;
     } else {
       p = new((void*) gvp) vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type) G__int(libp->para[0]), *(TEveProjection::PreScaleEntry_t*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type) G__int(libp->para[0]), *(TEveProjection::PreScaleEntry_t*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >(*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >(*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >(*((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::const_iterator*) G__int(libp->para[0])), *((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::const_iterator*) G__int(libp->para[1])));
   } else {
     p = new((void*) gvp) vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >(*((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::const_iterator*) G__int(libp->para[0])), *((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::const_iterator*) G__int(libp->para[1])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >& obj = ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->operator=(*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->reserve((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveProjection::PreScaleEntry_t& obj = ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->front();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveProjection::PreScaleEntry_t& obj = ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->back();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->push_back(*(TEveProjection::PreScaleEntry_t*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->swap(*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator* pobj;
         vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator xobj = ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->insert(*((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__int(libp->para[0])), *(TEveProjection::PreScaleEntry_t*) libp->para[1].ref);
         pobj = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->insert(*((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__int(libp->para[0])), *((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::const_iterator*) G__int(libp->para[1]))
, *((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::const_iterator*) G__int(libp->para[2])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->insert(*((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__int(libp->para[0])), (vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type) G__int(libp->para[1])
, *(TEveProjection::PreScaleEntry_t*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->pop_back();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->erase(*((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->erase(*((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__int(libp->para[0])), *((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_584_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) G__getstructoffset())->clear();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> > G__TvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR;
static int G__G__Eve1_584_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) (soff+(sizeof(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >)*i)))->~G__TvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*) (soff))->~G__TvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator */
static int G__G__Eve1_585_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator[n];
     } else {
       p = new((void*) gvp) vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator;
     } else {
       p = new((void*) gvp) vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_585_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator(libp->para[0].ref ? *(const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::pointer*) libp->para[0].ref : *(const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::pointer*) (void*) (&G__Mlong(libp->para[0])));
   } else {
     p = new((void*) gvp) vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator(libp->para[0].ref ? *(const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::pointer*) libp->para[0].ref : *(const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::pointer*) (void*) (&G__Mlong(libp->para[0])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_585_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::reference obj = ((const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__getstructoffset())->operator*();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_585_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__getstructoffset())->operator->());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_585_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator& obj = ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__getstructoffset())->operator++();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_585_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator* pobj;
         vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator xobj = ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__getstructoffset())->operator++((int) G__int(libp->para[0]));
         pobj = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_585_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator& obj = ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__getstructoffset())->operator--();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_585_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator* pobj;
         vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator xobj = ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__getstructoffset())->operator--((int) G__int(libp->para[0]));
         pobj = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_585_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::reference obj = ((const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__getstructoffset())->operator[](*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_585_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator& obj = ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__getstructoffset())->operator+=(*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_585_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator* pobj;
         const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator xobj = ((const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__getstructoffset())->operator+(*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         pobj = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_585_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator& obj = ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__getstructoffset())->operator-=(*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_585_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator* pobj;
         const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator xobj = ((const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__getstructoffset())->operator-(*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::difference_type*) G__Longref(&libp->para[0]));
         pobj = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_585_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::pointer& obj = ((const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__getstructoffset())->base();
         result7->ref = (long) (&obj);
         G__letint(result7, 'U', (long)obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_585_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator* pobj;
         vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator xobj = ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) G__getstructoffset())->operator=(*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) libp->para[0].ref);
         pobj = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_585_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator(*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator G__TvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator;
static int G__G__Eve1_585_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) (soff+(sizeof(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator)*i)))->~G__TvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) (soff))->~G__TvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveRhoZProjection */
static int G__G__Eve1_587_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRhoZProjection* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRhoZProjection[n];
     } else {
       p = new((void*) gvp) TEveRhoZProjection[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRhoZProjection;
     } else {
       p = new((void*) gvp) TEveRhoZProjection;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveRhoZProjection));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_587_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveRhoZProjection::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_587_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRhoZProjection::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_587_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveRhoZProjection::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_587_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveRhoZProjection::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_587_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRhoZProjection*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_587_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRhoZProjection::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_587_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRhoZProjection::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_587_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRhoZProjection::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_587_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRhoZProjection::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_587_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveRhoZProjection* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveRhoZProjection(*(TEveRhoZProjection*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveRhoZProjection));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveRhoZProjection G__TTEveRhoZProjection;
static int G__G__Eve1_587_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[] (TEveRhoZProjection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveRhoZProjection*) (soff+(sizeof(TEveRhoZProjection)*i)))->~G__TTEveRhoZProjection();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveRhoZProjection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveRhoZProjection*) (soff))->~G__TTEveRhoZProjection();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_587_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRhoZProjection* dest = (TEveRhoZProjection*) G__getstructoffset();
   *dest = *(TEveRhoZProjection*) libp->para[0].ref;
   const TEveRhoZProjection& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveRPhiProjection */
static int G__G__Eve1_588_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRPhiProjection* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRPhiProjection[n];
     } else {
       p = new((void*) gvp) TEveRPhiProjection[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRPhiProjection;
     } else {
       p = new((void*) gvp) TEveRPhiProjection;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveRPhiProjection));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_588_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveRPhiProjection::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_588_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRPhiProjection::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_588_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveRPhiProjection::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_588_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveRPhiProjection::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_588_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRPhiProjection*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_588_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRPhiProjection::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_588_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRPhiProjection::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_588_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRPhiProjection::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_588_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRPhiProjection::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_588_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveRPhiProjection* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveRPhiProjection(*(TEveRPhiProjection*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveRPhiProjection));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveRPhiProjection G__TTEveRPhiProjection;
static int G__G__Eve1_588_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[] (TEveRPhiProjection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveRPhiProjection*) (soff+(sizeof(TEveRPhiProjection)*i)))->~G__TTEveRPhiProjection();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveRPhiProjection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveRPhiProjection*) (soff))->~G__TTEveRPhiProjection();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_588_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRPhiProjection* dest = (TEveRPhiProjection*) G__getstructoffset();
   *dest = *(TEveRPhiProjection*) libp->para[0].ref;
   const TEveRPhiProjection& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEve3DProjection */
static int G__G__Eve1_589_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEve3DProjection* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEve3DProjection[n];
     } else {
       p = new((void*) gvp) TEve3DProjection[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEve3DProjection;
     } else {
       p = new((void*) gvp) TEve3DProjection;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEve3DProjection));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_589_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEve3DProjection::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_589_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEve3DProjection::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_589_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEve3DProjection::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_589_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEve3DProjection::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_589_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEve3DProjection*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_589_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEve3DProjection::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_589_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEve3DProjection::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_589_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEve3DProjection::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_589_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEve3DProjection::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_589_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEve3DProjection* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEve3DProjection(*(TEve3DProjection*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEve3DProjection));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEve3DProjection G__TTEve3DProjection;
static int G__G__Eve1_589_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[] (TEve3DProjection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEve3DProjection*) (soff+(sizeof(TEve3DProjection)*i)))->~G__TTEve3DProjection();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEve3DProjection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEve3DProjection*) (soff))->~G__TTEve3DProjection();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_589_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEve3DProjection* dest = (TEve3DProjection*) G__getstructoffset();
   *dest = *(TEve3DProjection*) libp->para[0].ref;
   const TEve3DProjection& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveSceneInfo */
static int G__G__Eve1_592_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveSceneInfo* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveSceneInfo(
(TEveViewer*) G__int(libp->para[0]), (TEveScene*) G__int(libp->para[1])
, (TGLSceneInfo*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TEveSceneInfo(
(TEveViewer*) G__int(libp->para[0]), (TEveScene*) G__int(libp->para[1])
, (TGLSceneInfo*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneInfo));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_592_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveSceneInfo*) G__getstructoffset())->GetViewer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_592_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveSceneInfo*) G__getstructoffset())->GetScene());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_592_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveSceneInfo*) G__getstructoffset())->GetGLSceneInfo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_592_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveSceneInfo*) G__getstructoffset())->GetGLScene());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_592_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveSceneInfo::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_592_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveSceneInfo::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_592_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveSceneInfo::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_592_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveSceneInfo::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_592_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSceneInfo*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_592_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveSceneInfo::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_592_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveSceneInfo::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_592_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveSceneInfo::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_592_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveSceneInfo::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveSceneInfo G__TTEveSceneInfo;
static int G__G__Eve1_592_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[] (TEveSceneInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveSceneInfo*) (soff+(sizeof(TEveSceneInfo)*i)))->~G__TTEveSceneInfo();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveSceneInfo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveSceneInfo*) (soff))->~G__TTEveSceneInfo();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTransEditor */
static int G__G__Eve1_601_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTransEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTransEditor(
(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) TEveTransEditor(
(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 TEveTransEditor(
(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) TEveTransEditor(
(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 TEveTransEditor(
(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) TEveTransEditor(
(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 TEveTransEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveTransEditor((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 TEveTransEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveTransEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveTransEditor[n];
       } else {
         p = new((void*) gvp) TEveTransEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveTransEditor;
       } else {
         p = new((void*) gvp) TEveTransEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveTransEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_601_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTransEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_601_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTransEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_601_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTransEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_601_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTransEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_601_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTransEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_601_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTransEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_601_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTransEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_601_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTransEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_601_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTransEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTransEditor G__TTEveTransEditor;
static int G__G__Eve1_601_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[] (TEveTransEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTransEditor*) (soff+(sizeof(TEveTransEditor)*i)))->~G__TTEveTransEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTransEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTransEditor*) (soff))->~G__TTEveTransEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveSelectorToEventList */
static int G__G__Eve1_648_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveSelectorToEventList* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveSelectorToEventList((TEventList*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TEveSelectorToEventList((TEventList*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveSelectorToEventList));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_648_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveSelectorToEventList::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_648_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveSelectorToEventList::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_648_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveSelectorToEventList::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_648_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveSelectorToEventList::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_648_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSelectorToEventList*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_648_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveSelectorToEventList::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_648_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveSelectorToEventList::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_648_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveSelectorToEventList::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_648_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveSelectorToEventList::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveSelectorToEventList G__TTEveSelectorToEventList;
static int G__G__Eve1_648_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[] (TEveSelectorToEventList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveSelectorToEventList*) (soff+(sizeof(TEveSelectorToEventList)*i)))->~G__TTEveSelectorToEventList();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveSelectorToEventList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveSelectorToEventList*) (soff))->~G__TTEveSelectorToEventList();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvePointSelector */
static int G__G__Eve1_649_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePointSelector* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePointSelector(
(TTree*) G__int(libp->para[0]), (TEvePointSelectorConsumer*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TEvePointSelector(
(TTree*) G__int(libp->para[0]), (TEvePointSelectorConsumer*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePointSelector(
(TTree*) G__int(libp->para[0]), (TEvePointSelectorConsumer*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEvePointSelector(
(TTree*) G__int(libp->para[0]), (TEvePointSelectorConsumer*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePointSelector((TTree*) G__int(libp->para[0]), (TEvePointSelectorConsumer*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEvePointSelector((TTree*) G__int(libp->para[0]), (TEvePointSelectorConsumer*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePointSelector((TTree*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEvePointSelector((TTree*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEvePointSelector[n];
       } else {
         p = new((void*) gvp) TEvePointSelector[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEvePointSelector;
       } else {
         p = new((void*) gvp) TEvePointSelector;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelector));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TEvePointSelector*) G__getstructoffset())->Select((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letLonglong(result7, 110, (G__int64) ((TEvePointSelector*) G__getstructoffset())->Select());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letLonglong(result7, 110, (G__int64) ((TEvePointSelector*) G__getstructoffset())->Select((TTree*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letLonglong(result7, 110, (G__int64) ((TEvePointSelector*) G__getstructoffset())->Select((TTree*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvePointSelector*) G__getstructoffset())->GetTree());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSelector*) G__getstructoffset())->SetTree((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvePointSelector*) G__getstructoffset())->GetConsumer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSelector*) G__getstructoffset())->SetConsumer((TEvePointSelectorConsumer*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TEvePointSelector*) G__getstructoffset())->GetVarexp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSelector*) G__getstructoffset())->SetVarexp((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TEvePointSelector*) G__getstructoffset())->GetSelection());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSelector*) G__getstructoffset())->SetSelection((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TEvePointSelector*) G__getstructoffset())->GetSubIdExp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSelector*) G__getstructoffset())->SetSubIdExp((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvePointSelector*) G__getstructoffset())->GetSubIdNum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvePointSelector::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSelector::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvePointSelector::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvePointSelector::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSelector*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSelector::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePointSelector::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSelector::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_649_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePointSelector::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvePointSelector G__TTEvePointSelector;
static int G__G__Eve1_649_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEvePointSelector*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvePointSelector*) (soff+(sizeof(TEvePointSelector)*i)))->~G__TTEvePointSelector();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvePointSelector*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvePointSelector*) (soff))->~G__TTEvePointSelector();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvePointSelectorConsumer */
static int G__G__Eve1_650_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSelectorConsumer*) G__getstructoffset())->InitFill((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_650_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSelectorConsumer*) G__getstructoffset())->TakeAction((TEvePointSelector*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_650_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvePointSelectorConsumer*) G__getstructoffset())->GetSourceCS());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_650_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSelectorConsumer*) G__getstructoffset())->SetSourceCS((TEvePointSelectorConsumer::ETreeVarType_e) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_650_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvePointSelectorConsumer::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_650_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSelectorConsumer::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_650_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvePointSelectorConsumer::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_650_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvePointSelectorConsumer::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_650_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvePointSelectorConsumer*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_650_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSelectorConsumer*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_650_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSelectorConsumer*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_650_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSelectorConsumer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_650_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSelectorConsumer::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_650_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePointSelectorConsumer::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_650_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSelectorConsumer::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_650_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePointSelectorConsumer::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvePointSelectorConsumer G__TTEvePointSelectorConsumer;
static int G__G__Eve1_650_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[] (TEvePointSelectorConsumer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvePointSelectorConsumer*) (soff+(sizeof(TEvePointSelectorConsumer)*i)))->~G__TTEvePointSelectorConsumer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvePointSelectorConsumer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvePointSelectorConsumer*) (soff))->~G__TTEvePointSelectorConsumer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_650_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePointSelectorConsumer* dest = (TEvePointSelectorConsumer*) G__getstructoffset();
   *dest = *(TEvePointSelectorConsumer*) libp->para[0].ref;
   const TEvePointSelectorConsumer& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvePathMarkT<float> */
static int G__G__Eve1_652_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePathMarkT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePathMarkT<float>((TEvePathMarkT<float>::EType_e) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEvePathMarkT<float>((TEvePathMarkT<float>::EType_e) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEvePathMarkT<float>[n];
       } else {
         p = new((void*) gvp) TEvePathMarkT<float>[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEvePathMarkT<float>;
       } else {
         p = new((void*) gvp) TEvePathMarkT<float>;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_652_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePathMarkT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePathMarkT<float>(
(TEvePathMarkT<float>::EType_e) G__int(libp->para[0]), *(TEveVectorT<float>*) libp->para[1].ref
, (float) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TEvePathMarkT<float>(
(TEvePathMarkT<float>::EType_e) G__int(libp->para[0]), *(TEveVectorT<float>*) libp->para[1].ref
, (float) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePathMarkT<float>((TEvePathMarkT<float>::EType_e) G__int(libp->para[0]), *(TEveVectorT<float>*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TEvePathMarkT<float>((TEvePathMarkT<float>::EType_e) G__int(libp->para[0]), *(TEveVectorT<float>*) libp->para[1].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_652_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePathMarkT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePathMarkT<float>(
(TEvePathMarkT<float>::EType_e) G__int(libp->para[0]), *(TEveVectorT<float>*) libp->para[1].ref
, *(TEveVectorT<float>*) libp->para[2].ref, (float) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TEvePathMarkT<float>(
(TEvePathMarkT<float>::EType_e) G__int(libp->para[0]), *(TEveVectorT<float>*) libp->para[1].ref
, *(TEveVectorT<float>*) libp->para[2].ref, (float) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePathMarkT<float>(
(TEvePathMarkT<float>::EType_e) G__int(libp->para[0]), *(TEveVectorT<float>*) libp->para[1].ref
, *(TEveVectorT<float>*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) TEvePathMarkT<float>(
(TEvePathMarkT<float>::EType_e) G__int(libp->para[0]), *(TEveVectorT<float>*) libp->para[1].ref
, *(TEveVectorT<float>*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_652_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePathMarkT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePathMarkT<float>(
(TEvePathMarkT<float>::EType_e) G__int(libp->para[0]), *(TEveVectorT<float>*) libp->para[1].ref
, *(TEveVectorT<float>*) libp->para[2].ref, *(TEveVectorT<float>*) libp->para[3].ref
, (float) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TEvePathMarkT<float>(
(TEvePathMarkT<float>::EType_e) G__int(libp->para[0]), *(TEveVectorT<float>*) libp->para[1].ref
, *(TEveVectorT<float>*) libp->para[2].ref, *(TEveVectorT<float>*) libp->para[3].ref
, (float) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePathMarkT<float>(
(TEvePathMarkT<float>::EType_e) G__int(libp->para[0]), *(TEveVectorT<float>*) libp->para[1].ref
, *(TEveVectorT<float>*) libp->para[2].ref, *(TEveVectorT<float>*) libp->para[3].ref);
     } else {
       p = new((void*) gvp) TEvePathMarkT<float>(
(TEvePathMarkT<float>::EType_e) G__int(libp->para[0]), *(TEveVectorT<float>*) libp->para[1].ref
, *(TEveVectorT<float>*) libp->para[2].ref, *(TEveVectorT<float>*) libp->para[3].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_652_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TEvePathMarkT<float>*) G__getstructoffset())->TypeName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_652_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvePathMarkT<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_652_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePathMarkT<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_652_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvePathMarkT<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_652_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvePathMarkT<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_652_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvePathMarkT<float>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_652_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePathMarkT<float>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_652_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePathMarkT<float>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_652_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePathMarkT<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_652_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePathMarkT<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_652_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePathMarkT<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_652_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePathMarkT<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_652_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePathMarkT<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_652_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEvePathMarkT<float>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEvePathMarkT<float>(*(TEvePathMarkT<float>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvePathMarkT<float> G__TTEvePathMarkTlEfloatgR;
static int G__G__Eve1_652_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[] (TEvePathMarkT<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvePathMarkT<float>*) (soff+(sizeof(TEvePathMarkT<float>)*i)))->~G__TTEvePathMarkTlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvePathMarkT<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvePathMarkT<float>*) (soff))->~G__TTEvePathMarkTlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_652_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePathMarkT<float>* dest = (TEvePathMarkT<float>*) G__getstructoffset();
   *dest = *(TEvePathMarkT<float>*) libp->para[0].ref;
   const TEvePathMarkT<float>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvePathMarkT<double> */
static int G__G__Eve1_654_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePathMarkT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePathMarkT<double>((TEvePathMarkT<double>::EType_e) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEvePathMarkT<double>((TEvePathMarkT<double>::EType_e) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEvePathMarkT<double>[n];
       } else {
         p = new((void*) gvp) TEvePathMarkT<double>[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEvePathMarkT<double>;
       } else {
         p = new((void*) gvp) TEvePathMarkT<double>;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_654_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePathMarkT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePathMarkT<double>(
(TEvePathMarkT<double>::EType_e) G__int(libp->para[0]), *(TEveVectorT<double>*) libp->para[1].ref
, (double) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TEvePathMarkT<double>(
(TEvePathMarkT<double>::EType_e) G__int(libp->para[0]), *(TEveVectorT<double>*) libp->para[1].ref
, (double) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePathMarkT<double>((TEvePathMarkT<double>::EType_e) G__int(libp->para[0]), *(TEveVectorT<double>*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TEvePathMarkT<double>((TEvePathMarkT<double>::EType_e) G__int(libp->para[0]), *(TEveVectorT<double>*) libp->para[1].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_654_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePathMarkT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePathMarkT<double>(
(TEvePathMarkT<double>::EType_e) G__int(libp->para[0]), *(TEveVectorT<double>*) libp->para[1].ref
, *(TEveVectorT<double>*) libp->para[2].ref, (double) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TEvePathMarkT<double>(
(TEvePathMarkT<double>::EType_e) G__int(libp->para[0]), *(TEveVectorT<double>*) libp->para[1].ref
, *(TEveVectorT<double>*) libp->para[2].ref, (double) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePathMarkT<double>(
(TEvePathMarkT<double>::EType_e) G__int(libp->para[0]), *(TEveVectorT<double>*) libp->para[1].ref
, *(TEveVectorT<double>*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) TEvePathMarkT<double>(
(TEvePathMarkT<double>::EType_e) G__int(libp->para[0]), *(TEveVectorT<double>*) libp->para[1].ref
, *(TEveVectorT<double>*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_654_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePathMarkT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePathMarkT<double>(
(TEvePathMarkT<double>::EType_e) G__int(libp->para[0]), *(TEveVectorT<double>*) libp->para[1].ref
, *(TEveVectorT<double>*) libp->para[2].ref, *(TEveVectorT<double>*) libp->para[3].ref
, (double) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TEvePathMarkT<double>(
(TEvePathMarkT<double>::EType_e) G__int(libp->para[0]), *(TEveVectorT<double>*) libp->para[1].ref
, *(TEveVectorT<double>*) libp->para[2].ref, *(TEveVectorT<double>*) libp->para[3].ref
, (double) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePathMarkT<double>(
(TEvePathMarkT<double>::EType_e) G__int(libp->para[0]), *(TEveVectorT<double>*) libp->para[1].ref
, *(TEveVectorT<double>*) libp->para[2].ref, *(TEveVectorT<double>*) libp->para[3].ref);
     } else {
       p = new((void*) gvp) TEvePathMarkT<double>(
(TEvePathMarkT<double>::EType_e) G__int(libp->para[0]), *(TEveVectorT<double>*) libp->para[1].ref
, *(TEveVectorT<double>*) libp->para[2].ref, *(TEveVectorT<double>*) libp->para[3].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_654_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TEvePathMarkT<double>*) G__getstructoffset())->TypeName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_654_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvePathMarkT<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_654_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePathMarkT<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_654_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvePathMarkT<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_654_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvePathMarkT<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_654_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvePathMarkT<double>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_654_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePathMarkT<double>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_654_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePathMarkT<double>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_654_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePathMarkT<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_654_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePathMarkT<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_654_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePathMarkT<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_654_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePathMarkT<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_654_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePathMarkT<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_654_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEvePathMarkT<double>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEvePathMarkT<double>(*(TEvePathMarkT<double>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvePathMarkT<double> G__TTEvePathMarkTlEdoublegR;
static int G__G__Eve1_654_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[] (TEvePathMarkT<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvePathMarkT<double>*) (soff+(sizeof(TEvePathMarkT<double>)*i)))->~G__TTEvePathMarkTlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvePathMarkT<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvePathMarkT<double>*) (soff))->~G__TTEvePathMarkTlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_654_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePathMarkT<double>* dest = (TEvePathMarkT<double>*) G__getstructoffset();
   *dest = *(TEvePathMarkT<double>*) libp->para[0].ref;
   const TEvePathMarkT<double>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveMCTrack */
static int G__G__Eve1_663_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveMCTrack* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveMCTrack[n];
     } else {
       p = new((void*) gvp) TEveMCTrack[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveMCTrack;
     } else {
       p = new((void*) gvp) TEveMCTrack;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveMCTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_663_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveMCTrack& obj = ((TEveMCTrack*) G__getstructoffset())->operator=(*(TParticle*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_663_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveMCTrack*) G__getstructoffset())->ResetPdgCode();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_663_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveMCTrack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_663_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMCTrack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_663_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveMCTrack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_663_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveMCTrack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_663_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveMCTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_663_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMCTrack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_663_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveMCTrack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_663_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMCTrack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_663_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveMCTrack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_663_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveMCTrack* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveMCTrack(*(TEveMCTrack*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveMCTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveMCTrack G__TTEveMCTrack;
static int G__G__Eve1_663_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[] (TEveMCTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveMCTrack*) (soff+(sizeof(TEveMCTrack)*i)))->~G__TTEveMCTrack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveMCTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveMCTrack*) (soff))->~G__TTEveMCTrack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_663_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveMCTrack* dest = (TEveMCTrack*) G__getstructoffset();
   *dest = *(TEveMCTrack*) libp->para[0].ref;
   const TEveMCTrack& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveHit */
static int G__G__Eve1_664_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveHit* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveHit[n];
     } else {
       p = new((void*) gvp) TEveHit[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveHit;
     } else {
       p = new((void*) gvp) TEveHit;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveHit));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_664_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveHit::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_664_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveHit::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_664_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveHit::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_664_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveHit::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_664_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveHit*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_664_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveHit::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_664_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveHit::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_664_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveHit::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_664_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveHit::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_664_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveHit* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveHit(*(TEveHit*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveHit));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveHit G__TTEveHit;
static int G__G__Eve1_664_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveHit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveHit*) (soff+(sizeof(TEveHit)*i)))->~G__TTEveHit();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveHit*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveHit*) (soff))->~G__TTEveHit();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_664_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveHit* dest = (TEveHit*) G__getstructoffset();
   *dest = *(TEveHit*) libp->para[0].ref;
   const TEveHit& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCluster */
static int G__G__Eve1_665_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCluster* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCluster[n];
     } else {
       p = new((void*) gvp) TEveCluster[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCluster;
     } else {
       p = new((void*) gvp) TEveCluster;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveCluster));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_665_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCluster::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_665_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCluster::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_665_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCluster::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_665_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCluster::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_665_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCluster*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_665_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCluster::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_665_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCluster::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_665_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCluster::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_665_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCluster::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_665_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveCluster* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveCluster(*(TEveCluster*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveCluster));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCluster G__TTEveCluster;
static int G__G__Eve1_665_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveCluster*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCluster*) (soff+(sizeof(TEveCluster)*i)))->~G__TTEveCluster();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCluster*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCluster*) (soff))->~G__TTEveCluster();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_665_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCluster* dest = (TEveCluster*) G__getstructoffset();
   *dest = *(TEveCluster*) libp->para[0].ref;
   const TEveCluster& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveRecTrack */
static int G__G__Eve1_666_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRecTrack* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRecTrack[n];
     } else {
       p = new((void*) gvp) TEveRecTrack[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRecTrack;
     } else {
       p = new((void*) gvp) TEveRecTrack;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveRecTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_666_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TEveRecTrack*) G__getstructoffset())->Pt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_666_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveRecTrack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_666_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRecTrack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_666_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveRecTrack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_666_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveRecTrack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_666_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRecTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_666_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRecTrack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_666_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRecTrack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_666_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRecTrack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_666_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRecTrack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_666_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveRecTrack* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveRecTrack(*(TEveRecTrack*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveRecTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveRecTrack G__TTEveRecTrack;
static int G__G__Eve1_666_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveRecTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveRecTrack*) (soff+(sizeof(TEveRecTrack)*i)))->~G__TTEveRecTrack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveRecTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveRecTrack*) (soff))->~G__TTEveRecTrack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_666_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRecTrack* dest = (TEveRecTrack*) G__getstructoffset();
   *dest = *(TEveRecTrack*) libp->para[0].ref;
   const TEveRecTrack& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveRecKink */
static int G__G__Eve1_667_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRecKink* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRecKink[n];
     } else {
       p = new((void*) gvp) TEveRecKink[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRecKink;
     } else {
       p = new((void*) gvp) TEveRecKink;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveRecKink));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_667_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveRecKink::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_667_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRecKink::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_667_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveRecKink::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_667_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveRecKink::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_667_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRecKink*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_667_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRecKink::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_667_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRecKink::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_667_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRecKink::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_667_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRecKink::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_667_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveRecKink* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveRecKink(*(TEveRecKink*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveRecKink));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveRecKink G__TTEveRecKink;
static int G__G__Eve1_667_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveRecKink*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveRecKink*) (soff+(sizeof(TEveRecKink)*i)))->~G__TTEveRecKink();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveRecKink*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveRecKink*) (soff))->~G__TTEveRecKink();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_667_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRecKink* dest = (TEveRecKink*) G__getstructoffset();
   *dest = *(TEveRecKink*) libp->para[0].ref;
   const TEveRecKink& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveRecV0 */
static int G__G__Eve1_668_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRecV0* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRecV0[n];
     } else {
       p = new((void*) gvp) TEveRecV0[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRecV0;
     } else {
       p = new((void*) gvp) TEveRecV0;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveRecV0));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_668_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveRecV0::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_668_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRecV0::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_668_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveRecV0::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_668_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveRecV0::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_668_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRecV0*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_668_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRecV0::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_668_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRecV0::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_668_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRecV0::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_668_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRecV0::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_668_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveRecV0* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveRecV0(*(TEveRecV0*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveRecV0));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveRecV0 G__TTEveRecV0;
static int G__G__Eve1_668_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveRecV0*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveRecV0*) (soff+(sizeof(TEveRecV0)*i)))->~G__TTEveRecV0();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveRecV0*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveRecV0*) (soff))->~G__TTEveRecV0();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_668_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRecV0* dest = (TEveRecV0*) G__getstructoffset();
   *dest = *(TEveRecV0*) libp->para[0].ref;
   const TEveRecV0& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveRecCascade */
static int G__G__Eve1_669_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRecCascade* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRecCascade[n];
     } else {
       p = new((void*) gvp) TEveRecCascade[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRecCascade;
     } else {
       p = new((void*) gvp) TEveRecCascade;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveRecCascade));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_669_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveRecCascade::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_669_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRecCascade::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_669_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveRecCascade::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_669_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveRecCascade::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_669_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRecCascade*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_669_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRecCascade::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_669_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRecCascade::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_669_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRecCascade::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_669_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRecCascade::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_669_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveRecCascade* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveRecCascade(*(TEveRecCascade*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveRecCascade));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveRecCascade G__TTEveRecCascade;
static int G__G__Eve1_669_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveRecCascade*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveRecCascade*) (soff+(sizeof(TEveRecCascade)*i)))->~G__TTEveRecCascade();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveRecCascade*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveRecCascade*) (soff))->~G__TTEveRecCascade();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_669_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRecCascade* dest = (TEveRecCascade*) G__getstructoffset();
   *dest = *(TEveRecCascade*) libp->para[0].ref;
   const TEveRecCascade& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveMCRecCrossRef */
static int G__G__Eve1_670_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveMCRecCrossRef* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveMCRecCrossRef[n];
     } else {
       p = new((void*) gvp) TEveMCRecCrossRef[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveMCRecCrossRef;
     } else {
       p = new((void*) gvp) TEveMCRecCrossRef;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveMCRecCrossRef));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_670_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveMCRecCrossRef::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_670_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMCRecCrossRef::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_670_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveMCRecCrossRef::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_670_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveMCRecCrossRef::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_670_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveMCRecCrossRef*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_670_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMCRecCrossRef::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_670_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveMCRecCrossRef::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_670_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMCRecCrossRef::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_670_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveMCRecCrossRef::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve1_670_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveMCRecCrossRef* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveMCRecCrossRef(*(TEveMCRecCrossRef*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveMCRecCrossRef));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveMCRecCrossRef G__TTEveMCRecCrossRef;
static int G__G__Eve1_670_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveMCRecCrossRef*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveMCRecCrossRef*) (soff+(sizeof(TEveMCRecCrossRef)*i)))->~G__TTEveMCRecCrossRef();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveMCRecCrossRef*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveMCRecCrossRef*) (soff))->~G__TTEveMCRecCrossRef();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve1_670_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveMCRecCrossRef* dest = (TEveMCRecCrossRef*) G__getstructoffset();
   *dest = *(TEveMCRecCrossRef*) libp->para[0].ref;
   const TEveMCRecCrossRef& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveVSD */
static int G__G__Eve1_718_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveVSD* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVSD((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveVSD((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveVSD((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveVSD((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveVSD[n];
       } else {
         p = new((void*) gvp) TEveVSD[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveVSD;
       } else {
         p = new((void*) gvp) TEveVSD;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveVSD));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_718_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVSD*) G__getstructoffset())->SetDirectory((TDirectory*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_718_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVSD*) G__getstructoffset())->CreateTrees();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_718_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVSD*) G__getstructoffset())->DeleteTrees();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_718_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVSD*) G__getstructoffset())->CreateBranches();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_718_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVSD*) G__getstructoffset())->WriteTrees();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_718_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVSD*) G__getstructoffset())->LoadTrees();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_718_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVSD*) G__getstructoffset())->SetBranchAddresses();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_718_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveVSD::DisableTObjectStreamersForVSDStruct();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_718_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveVSD::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_718_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVSD::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_718_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveVSD::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_718_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveVSD::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_718_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveVSD*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_718_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVSD::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_718_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveVSD::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_718_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveVSD::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_718_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveVSD::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveVSD G__TTEveVSD;
static int G__G__Eve1_718_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[] (TEveVSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveVSD*) (soff+(sizeof(TEveVSD)*i)))->~G__TTEveVSD();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveVSD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveVSD*) (soff))->~G__TTEveVSD();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveWindow */
static int G__G__Eve1_719_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveWindow*) G__getstructoffset())->GetGUIFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindow*) G__getstructoffset())->PreUndock();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindow*) G__getstructoffset())->PostDock();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveWindow*) G__getstructoffset())->CanMakeNewSlots());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveWindow*) G__getstructoffset())->NewSlot());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindow*) G__getstructoffset())->PopulateEmptyFrame((TEveCompositeFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindow*) G__getstructoffset())->SwapWindow((TEveWindow*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindow*) G__getstructoffset())->SwapWindowWithCurrent();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindow*) G__getstructoffset())->UndockWindow();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindow*) G__getstructoffset())->UndockWindowDestroySlot();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindow*) G__getstructoffset())->ReplaceWindow((TEveWindow*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindow*) G__getstructoffset())->DestroyWindow();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindow*) G__getstructoffset())->DestroyWindowAndSlot();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveWindow*) G__getstructoffset())->GetEveFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindow*) G__getstructoffset())->ClearEveFrame();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindow*) G__getstructoffset())->FlipShowTitleBar();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveWindow*) G__getstructoffset())->GetShowTitleBar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindow*) G__getstructoffset())->SetShowTitleBar((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveWindow*) G__getstructoffset())->IsCurrent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindow*) G__getstructoffset())->MakeCurrent();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveWindow*) G__getstructoffset())->IsAncestorOf((TEveWindow*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindow*) G__getstructoffset())->TitleBarClicked();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveWindow::CreateDefaultWindowSlot());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) TEveWindow::CreateWindowMainFrame((TEveWindow*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) TEveWindow::CreateWindowMainFrame());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) TEveWindow::CreateWindowInTab((TGTab*) G__int(libp->para[0]), (TEveWindow*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TEveWindow::CreateWindowInTab((TGTab*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveWindow::SwapWindows((TEveWindow*) G__int(libp->para[0]), (TEveWindow*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) TEveWindow::GetMainFrameDefWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) TEveWindow::GetMainFrameDefHeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveWindow::SetMainFrameDefWidth((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveWindow::SetMainFrameDefHeight((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TEveWindow::GetCurrentBackgroundColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) TEveWindow::GetMiniBarBackgroundColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveWindow::SetCurrentBackgroundColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveWindow::SetMiniBarBackgroundColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveWindow::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindow::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveWindow::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveWindow::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindow*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindow::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveWindow::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindow::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_719_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveWindow::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveWindow G__TTEveWindow;
static int G__G__Eve1_719_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveWindow*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveWindow*) (soff+(sizeof(TEveWindow)*i)))->~G__TTEveWindow();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveWindow*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveWindow*) (soff))->~G__TTEveWindow();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveWindowSlot */
static int G__G__Eve1_720_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveWindowSlot* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveWindowSlot((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveWindowSlot((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveWindowSlot((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveWindowSlot((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveWindowSlot[n];
       } else {
         p = new((void*) gvp) TEveWindowSlot[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveWindowSlot;
       } else {
         p = new((void*) gvp) TEveWindowSlot;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_720_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveWindowSlot*) G__getstructoffset())->MakePack());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_720_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveWindowSlot*) G__getstructoffset())->MakeTab());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_720_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TEveWindowSlot*) G__getstructoffset())->MakeFrame((TGFrame*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TEveWindowSlot*) G__getstructoffset())->MakeFrame());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_720_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveWindowSlot*) G__getstructoffset())->StartEmbedding());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_720_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TEveWindowSlot*) G__getstructoffset())->StopEmbedding((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TEveWindowSlot*) G__getstructoffset())->StopEmbedding());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_720_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveWindowSlot::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_720_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowSlot::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_720_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveWindowSlot::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_720_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveWindowSlot::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_720_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowSlot*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_720_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowSlot::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_720_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveWindowSlot::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_720_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowSlot::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_720_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveWindowSlot::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveWindowSlot G__TTEveWindowSlot;
static int G__G__Eve1_720_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveWindowSlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveWindowSlot*) (soff+(sizeof(TEveWindowSlot)*i)))->~G__TTEveWindowSlot();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveWindowSlot*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveWindowSlot*) (soff))->~G__TTEveWindowSlot();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveWindowFrame */
static int G__G__Eve1_721_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveWindowFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveWindowFrame(
(TGFrame*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveWindowFrame(
(TGFrame*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveWindowFrame((TGFrame*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveWindowFrame((TGFrame*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveWindowFrame((TGFrame*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveWindowFrame((TGFrame*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_721_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveWindowFrame*) G__getstructoffset())->GetGUICompositeFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_721_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveWindowFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_721_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_721_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveWindowFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_721_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveWindowFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_721_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_721_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_721_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveWindowFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_721_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_721_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveWindowFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveWindowFrame G__TTEveWindowFrame;
static int G__G__Eve1_721_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[] (TEveWindowFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveWindowFrame*) (soff+(sizeof(TEveWindowFrame)*i)))->~G__TTEveWindowFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveWindowFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveWindowFrame*) (soff))->~G__TTEveWindowFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveWindowPack */
static int G__G__Eve1_723_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveWindowPack* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveWindowPack(
(TGPack*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveWindowPack(
(TGPack*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveWindowPack((TGPack*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveWindowPack((TGPack*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveWindowPack((TGPack*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveWindowPack((TGPack*) 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__Eve1LN_TEveWindowPack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_723_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveWindowPack*) G__getstructoffset())->NewSlotWithWeight((Float_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_723_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowPack*) G__getstructoffset())->FlipOrientation();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_723_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveWindowPack*) G__getstructoffset())->SetVertical((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveWindowPack*) G__getstructoffset())->SetVertical();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_723_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowPack*) G__getstructoffset())->SetHorizontal();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_723_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowPack*) G__getstructoffset())->EqualizeFrames();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_723_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveWindowPack*) G__getstructoffset())->GetPack());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_723_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveWindowPack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_723_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowPack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_723_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveWindowPack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_723_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveWindowPack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_723_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowPack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_723_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowPack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_723_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveWindowPack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_723_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowPack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_723_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveWindowPack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveWindowPack G__TTEveWindowPack;
static int G__G__Eve1_723_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveWindowPack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveWindowPack*) (soff+(sizeof(TEveWindowPack)*i)))->~G__TTEveWindowPack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveWindowPack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveWindowPack*) (soff))->~G__TTEveWindowPack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveWindowTab */
static int G__G__Eve1_724_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveWindowTab* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveWindowTab(
(TGTab*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveWindowTab(
(TGTab*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveWindowTab((TGTab*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveWindowTab((TGTab*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveWindowTab((TGTab*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveWindowTab((TGTab*) 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__Eve1LN_TEveWindowTab));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_724_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveWindowTab*) G__getstructoffset())->GetTab());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_724_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveWindowTab::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_724_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowTab::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_724_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveWindowTab::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_724_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveWindowTab::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_724_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowTab*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_724_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowTab::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_724_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveWindowTab::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_724_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowTab::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_724_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveWindowTab::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveWindowTab G__TTEveWindowTab;
static int G__G__Eve1_724_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[] (TEveWindowTab*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveWindowTab*) (soff+(sizeof(TEveWindowTab)*i)))->~G__TTEveWindowTab();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveWindowTab*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveWindowTab*) (soff))->~G__TTEveWindowTab();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCompositeFrame */
static int G__G__Eve1_726_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompositeFrame*) G__getstructoffset())->WindowNameChanged(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompositeFrame*) G__getstructoffset())->Destroy();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompositeFrame*) G__getstructoffset())->AcquireEveWindow((TEveWindow*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TEveCompositeFrame*) G__getstructoffset())->RelinquishEveWindow((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TEveCompositeFrame*) G__getstructoffset())->RelinquishEveWindow());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveCompositeFrame*) G__getstructoffset())->GetEveWindow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveCompositeFrame*) G__getstructoffset())->GetEveParentAsWindow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompositeFrame*) G__getstructoffset())->SetCurrent((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompositeFrame*) G__getstructoffset())->SetShowTitleBar((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompositeFrame*) G__getstructoffset())->HideAllDecorations();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompositeFrame*) G__getstructoffset())->ShowNormalDecorations();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompositeFrame*) G__getstructoffset())->ActionPressed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompositeFrame*) G__getstructoffset())->FlipTitleBarState();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompositeFrame*) G__getstructoffset())->TitleBarClicked();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      TEveCompositeFrame::SetupFrameMarkup((TEveCompositeFrame::IconBarCreator_foo) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      TEveCompositeFrame::SetupFrameMarkup((TEveCompositeFrame::IconBarCreator_foo) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      TEveCompositeFrame::SetupFrameMarkup((TEveCompositeFrame::IconBarCreator_foo) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      TEveCompositeFrame::SetupFrameMarkup((TEveCompositeFrame::IconBarCreator_foo) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCompositeFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompositeFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCompositeFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCompositeFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompositeFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompositeFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCompositeFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompositeFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_726_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCompositeFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCompositeFrame G__TTEveCompositeFrame;
static int G__G__Eve1_726_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveCompositeFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCompositeFrame*) (soff+(sizeof(TEveCompositeFrame)*i)))->~G__TTEveCompositeFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCompositeFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCompositeFrame*) (soff))->~G__TTEveCompositeFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCompositeFrameInMainFrame */
static int G__G__Eve1_727_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCompositeFrameInMainFrame* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveCompositeFrameInMainFrame(
(TGCompositeFrame*) G__int(libp->para[0]), (TEveWindow*) G__int(libp->para[1])
, (TGMainFrame*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TEveCompositeFrameInMainFrame(
(TGCompositeFrame*) G__int(libp->para[0]), (TEveWindow*) G__int(libp->para[1])
, (TGMainFrame*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInMainFrame));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_727_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompositeFrameInMainFrame*) G__getstructoffset())->SetOriginalSlotAndContainer((TEveWindow*) G__int(libp->para[0]), (TEveWindow*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_727_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompositeFrameInMainFrame*) G__getstructoffset())->SomeWindowClosed((TEveWindow*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_727_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompositeFrameInMainFrame*) G__getstructoffset())->MainFrameClosed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_727_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveCompositeFrameInMainFrame*) G__getstructoffset())->GetOriginalSlot());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_727_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveCompositeFrameInMainFrame*) G__getstructoffset())->GetOriginalContainer());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_727_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCompositeFrameInMainFrame::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_727_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompositeFrameInMainFrame::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_727_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCompositeFrameInMainFrame::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_727_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCompositeFrameInMainFrame::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_727_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompositeFrameInMainFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_727_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompositeFrameInMainFrame::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_727_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCompositeFrameInMainFrame::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_727_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompositeFrameInMainFrame::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_727_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCompositeFrameInMainFrame::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCompositeFrameInMainFrame G__TTEveCompositeFrameInMainFrame;
static int G__G__Eve1_727_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveCompositeFrameInMainFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCompositeFrameInMainFrame*) (soff+(sizeof(TEveCompositeFrameInMainFrame)*i)))->~G__TTEveCompositeFrameInMainFrame();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCompositeFrameInMainFrame*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCompositeFrameInMainFrame*) (soff))->~G__TTEveCompositeFrameInMainFrame();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCompositeFrameInPack */
static int G__G__Eve1_728_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCompositeFrameInPack* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveCompositeFrameInPack(
(TGCompositeFrame*) G__int(libp->para[0]), (TEveWindow*) G__int(libp->para[1])
, (TGPack*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TEveCompositeFrameInPack(
(TGCompositeFrame*) G__int(libp->para[0]), (TEveWindow*) G__int(libp->para[1])
, (TGPack*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInPack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_728_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCompositeFrameInPack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_728_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompositeFrameInPack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_728_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCompositeFrameInPack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_728_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCompositeFrameInPack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_728_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompositeFrameInPack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_728_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompositeFrameInPack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_728_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCompositeFrameInPack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_728_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompositeFrameInPack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_728_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCompositeFrameInPack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCompositeFrameInPack G__TTEveCompositeFrameInPack;
static int G__G__Eve1_728_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[] (TEveCompositeFrameInPack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCompositeFrameInPack*) (soff+(sizeof(TEveCompositeFrameInPack)*i)))->~G__TTEveCompositeFrameInPack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCompositeFrameInPack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCompositeFrameInPack*) (soff))->~G__TTEveCompositeFrameInPack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCompositeFrameInTab */
static int G__G__Eve1_729_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCompositeFrameInTab* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveCompositeFrameInTab(
(TGCompositeFrame*) G__int(libp->para[0]), (TEveWindow*) G__int(libp->para[1])
, (TGTab*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TEveCompositeFrameInTab(
(TGCompositeFrame*) G__int(libp->para[0]), (TEveWindow*) G__int(libp->para[1])
, (TGTab*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInTab));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_729_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCompositeFrameInTab::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_729_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompositeFrameInTab::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_729_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCompositeFrameInTab::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_729_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCompositeFrameInTab::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_729_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCompositeFrameInTab*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_729_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompositeFrameInTab::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_729_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCompositeFrameInTab::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_729_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCompositeFrameInTab::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_729_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCompositeFrameInTab::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCompositeFrameInTab G__TTEveCompositeFrameInTab;
static int G__G__Eve1_729_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[] (TEveCompositeFrameInTab*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCompositeFrameInTab*) (soff+(sizeof(TEveCompositeFrameInTab)*i)))->~G__TTEveCompositeFrameInTab();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCompositeFrameInTab*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCompositeFrameInTab*) (soff))->~G__TTEveCompositeFrameInTab();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveViewerListEditor */
static int G__G__Eve1_732_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveViewerListEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveViewerListEditor(
(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) TEveViewerListEditor(
(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 TEveViewerListEditor(
(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) TEveViewerListEditor(
(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 TEveViewerListEditor(
(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) TEveViewerListEditor(
(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 TEveViewerListEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveViewerListEditor((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 TEveViewerListEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveViewerListEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveViewerListEditor[n];
       } else {
         p = new((void*) gvp) TEveViewerListEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveViewerListEditor;
       } else {
         p = new((void*) gvp) TEveViewerListEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerListEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_732_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerListEditor*) G__getstructoffset())->DoBrightness();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_732_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerListEditor*) G__getstructoffset())->SwitchColorSet();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_732_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveViewerListEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_732_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveViewerListEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_732_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveViewerListEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_732_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveViewerListEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_732_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveViewerListEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_732_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveViewerListEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_732_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveViewerListEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_732_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveViewerListEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_732_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveViewerListEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveViewerListEditor G__TTEveViewerListEditor;
static int G__G__Eve1_732_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[] (TEveViewerListEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveViewerListEditor*) (soff+(sizeof(TEveViewerListEditor)*i)))->~G__TTEveViewerListEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveViewerListEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveViewerListEditor*) (soff))->~G__TTEveViewerListEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveWindowEditor */
static int G__G__Eve1_733_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveWindowEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveWindowEditor(
(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) TEveWindowEditor(
(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 TEveWindowEditor(
(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) TEveWindowEditor(
(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 TEveWindowEditor(
(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) TEveWindowEditor(
(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 TEveWindowEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveWindowEditor((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 TEveWindowEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveWindowEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveWindowEditor[n];
       } else {
         p = new((void*) gvp) TEveWindowEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveWindowEditor;
       } else {
         p = new((void*) gvp) TEveWindowEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_733_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowEditor*) G__getstructoffset())->DoShowTitleBar();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_733_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveWindowEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_733_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_733_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveWindowEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_733_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveWindowEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_733_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveWindowEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_733_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_733_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveWindowEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_733_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveWindowEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_733_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveWindowEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveWindowEditor G__TTEveWindowEditor;
static int G__G__Eve1_733_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[] (TEveWindowEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveWindowEditor*) (soff+(sizeof(TEveWindowEditor)*i)))->~G__TTEveWindowEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveWindowEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveWindowEditor*) (soff))->~G__TTEveWindowEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveSecondarySelectable */
static int G__G__Eve1_734_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveSecondarySelectable* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveSecondarySelectable[n];
     } else {
       p = new((void*) gvp) TEveSecondarySelectable[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveSecondarySelectable;
     } else {
       p = new((void*) gvp) TEveSecondarySelectable;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve1LN_TEveSecondarySelectable));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_734_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveSecondarySelectable*) G__getstructoffset())->GetAlwaysSecSelect());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_734_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSecondarySelectable*) G__getstructoffset())->SetAlwaysSecSelect((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_734_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveSecondarySelectable::SelectionSet_t& obj = ((const TEveSecondarySelectable*) G__getstructoffset())->RefSelectedSet();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_734_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveSecondarySelectable::SelectionSet_t& obj = ((const TEveSecondarySelectable*) G__getstructoffset())->RefHighlightedSet();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_734_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSecondarySelectable*) G__getstructoffset())->ProcessGLSelection(*(TGLSelectRecord*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_734_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveSecondarySelectable::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_734_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveSecondarySelectable::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_734_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveSecondarySelectable::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_734_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveSecondarySelectable::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_734_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveSecondarySelectable*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_734_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSecondarySelectable*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_734_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSecondarySelectable*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_734_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveSecondarySelectable*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_734_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveSecondarySelectable::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_734_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveSecondarySelectable::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_734_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveSecondarySelectable::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1_734_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveSecondarySelectable::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveSecondarySelectable G__TTEveSecondarySelectable;
static int G__G__Eve1_734_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[] (TEveSecondarySelectable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveSecondarySelectable*) (soff+(sizeof(TEveSecondarySelectable)*i)))->~G__TTEveSecondarySelectable();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveSecondarySelectable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveSecondarySelectable*) (soff))->~G__TTEveSecondarySelectable();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */
static int G__G__Eve1__0_1565(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) libp->para[0].ref, *(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1__0_1566(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator!=(*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) libp->para[0].ref, *(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1__0_1567(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<(*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) libp->para[0].ref, *(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1__0_1568(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>(*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) libp->para[0].ref, *(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1__0_1569(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator<=(*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) libp->para[0].ref, *(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1__0_1570(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator>=(*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) libp->para[0].ref, *(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1__0_1571(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 108, (long) operator-(*(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) libp->para[0].ref, *(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1__0_1572(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator* pobj;
         const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator xobj = operator+((const vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::difference_type) G__int(libp->para[0]), *(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*) libp->para[1].ref);
         pobj = new vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve1__0_1678(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVectorT<float>* pobj;
         TEveVectorT<float> xobj = operator+(*(TEveVectorT<float>*) libp->para[0].ref, *(TEveVectorT<float>*) libp->para[1].ref);
         pobj = new TEveVectorT<float>(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__Eve1__0_1679(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVectorT<float>* pobj;
         TEveVectorT<float> xobj = operator-(*(TEveVectorT<float>*) libp->para[0].ref, *(TEveVectorT<float>*) libp->para[1].ref);
         pobj = new TEveVectorT<float>(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__Eve1__0_1680(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVectorT<float>* pobj;
         TEveVectorT<float> xobj = operator*(*(TEveVectorT<float>*) libp->para[0].ref, (float) G__double(libp->para[1]));
         pobj = new TEveVectorT<float>(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__Eve1__0_1681(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVectorT<float>* pobj;
         TEveVectorT<float> xobj = operator*((float) G__double(libp->para[0]), *(TEveVectorT<float>*) libp->para[1].ref);
         pobj = new TEveVectorT<float>(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__Eve1__0_1682(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector4T<float>* pobj;
         TEveVector4T<float> xobj = operator+(*(TEveVector4T<float>*) libp->para[0].ref, *(TEveVector4T<float>*) libp->para[1].ref);
         pobj = new TEveVector4T<float>(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__Eve1__0_1683(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector4T<float>* pobj;
         TEveVector4T<float> xobj = operator-(*(TEveVector4T<float>*) libp->para[0].ref, *(TEveVector4T<float>*) libp->para[1].ref);
         pobj = new TEveVector4T<float>(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__Eve1__0_1684(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector4T<float>* pobj;
         TEveVector4T<float> xobj = operator*(*(TEveVector4T<float>*) libp->para[0].ref, (float) G__double(libp->para[1]));
         pobj = new TEveVector4T<float>(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__Eve1__0_1685(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector4T<float>* pobj;
         TEveVector4T<float> xobj = operator*((float) G__double(libp->para[0]), *(TEveVector4T<float>*) libp->para[1].ref);
         pobj = new TEveVector4T<float>(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__Eve1__0_1686(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector2T<float>* pobj;
         TEveVector2T<float> xobj = operator+(*(TEveVector2T<float>*) libp->para[0].ref, *(TEveVector2T<float>*) libp->para[1].ref);
         pobj = new TEveVector2T<float>(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__Eve1__0_1687(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector2T<float>* pobj;
         TEveVector2T<float> xobj = operator-(*(TEveVector2T<float>*) libp->para[0].ref, *(TEveVector2T<float>*) libp->para[1].ref);
         pobj = new TEveVector2T<float>(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__Eve1__0_1688(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector2T<float>* pobj;
         TEveVector2T<float> xobj = operator*(*(TEveVector2T<float>*) libp->para[0].ref, (float) G__double(libp->para[1]));
         pobj = new TEveVector2T<float>(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__Eve1__0_1689(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector2T<float>* pobj;
         TEveVector2T<float> xobj = operator*((float) G__double(libp->para[0]), *(TEveVector2T<float>*) libp->para[1].ref);
         pobj = new TEveVector2T<float>(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__Eve1__0_1690(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVectorT<double>* pobj;
         TEveVectorT<double> xobj = operator+(*(TEveVectorT<double>*) libp->para[0].ref, *(TEveVectorT<double>*) libp->para[1].ref);
         pobj = new TEveVectorT<double>(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__Eve1__0_1691(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVectorT<double>* pobj;
         TEveVectorT<double> xobj = operator-(*(TEveVectorT<double>*) libp->para[0].ref, *(TEveVectorT<double>*) libp->para[1].ref);
         pobj = new TEveVectorT<double>(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__Eve1__0_1692(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVectorT<double>* pobj;
         TEveVectorT<double> xobj = operator*(*(TEveVectorT<double>*) libp->para[0].ref, (double) G__double(libp->para[1]));
         pobj = new TEveVectorT<double>(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__Eve1__0_1693(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVectorT<double>* pobj;
         TEveVectorT<double> xobj = operator*((double) G__double(libp->para[0]), *(TEveVectorT<double>*) libp->para[1].ref);
         pobj = new TEveVectorT<double>(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__Eve1__0_1694(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector4T<double>* pobj;
         TEveVector4T<double> xobj = operator+(*(TEveVector4T<double>*) libp->para[0].ref, *(TEveVector4T<double>*) libp->para[1].ref);
         pobj = new TEveVector4T<double>(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__Eve1__0_1695(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector4T<double>* pobj;
         TEveVector4T<double> xobj = operator-(*(TEveVector4T<double>*) libp->para[0].ref, *(TEveVector4T<double>*) libp->para[1].ref);
         pobj = new TEveVector4T<double>(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__Eve1__0_1696(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector4T<double>* pobj;
         TEveVector4T<double> xobj = operator*(*(TEveVector4T<double>*) libp->para[0].ref, (double) G__double(libp->para[1]));
         pobj = new TEveVector4T<double>(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__Eve1__0_1697(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector4T<double>* pobj;
         TEveVector4T<double> xobj = operator*((double) G__double(libp->para[0]), *(TEveVector4T<double>*) libp->para[1].ref);
         pobj = new TEveVector4T<double>(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__Eve1__0_1698(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector2T<double>* pobj;
         TEveVector2T<double> xobj = operator+(*(TEveVector2T<double>*) libp->para[0].ref, *(TEveVector2T<double>*) libp->para[1].ref);
         pobj = new TEveVector2T<double>(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__Eve1__0_1699(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector2T<double>* pobj;
         TEveVector2T<double> xobj = operator-(*(TEveVector2T<double>*) libp->para[0].ref, *(TEveVector2T<double>*) libp->para[1].ref);
         pobj = new TEveVector2T<double>(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__Eve1__0_1700(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector2T<double>* pobj;
         TEveVector2T<double> xobj = operator*(*(TEveVector2T<double>*) libp->para[0].ref, (double) G__double(libp->para[1]));
         pobj = new TEveVector2T<double>(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__Eve1__0_1701(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector2T<double>* pobj;
         TEveVector2T<double> xobj = operator*((double) G__double(libp->para[0]), *(TEveVector2T<double>*) libp->para[1].ref);
         pobj = new TEveVector2T<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}


/*********************************************************
* Member function Stub
*********************************************************/

/* TEveElement */

/* TEveUtil */

/* TEveException */

/* TEvePadHolder */

/* TEveGeoManagerHolder */

/* TEveRefCnt */

/* TEveRefBackPtr */

/* TEveProjection */

/* TEveProjected */

/* TEveProjectionManager */

/* TEveProjectable */

/* set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> > */

/* set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator */

/* TEveCompound */

/* TEveTrans */

/* TEveManager */

/* TEveElement::TEveListTreeInfo */

/* list<TEveElement*,allocator<TEveElement*> > */

/* list<TEveElement*,allocator<TEveElement*> >::iterator */

/* TEveElementObjectPtr */

/* TEveElementList */

/* TEveElementListProjected */

/* TEveGedEditor */

/* TEveListTreeItem */

/* TEveGListTreeEditorFrame */

/* TEveBrowser */

/* TEveChunkManager */

/* TEveChunkManager::iterator */

/* TEveCompoundProjected */

/* TEveTransSubEditor */

/* TEveElementEditor */

/* TEveEventManager */

/* TEveGValuatorBase */

/* TEveGValuator */

/* TEveGDoubleValuator */

/* TEveGTriVecValuator */

/* TEveGedNameFrame */

/* TEveGedNameTextButton */

/* TEveMacro */

/* TEveSelection */

/* TEveViewer */

/* TEveViewerList */

/* TEveScene */

/* TEveSceneList */

/* TEveWindowManager */

/* TEveManager::TRedrawDisabler */

/* TEveManager::TExceptionHandler */

/* TEvePad */

/* TEveParamList */

/* TEveParamListEditor */

/* TEveParamList::FloatConfig_t */

/* TEveParamList::IntConfig_t */

/* TEveParamList::BoolConfig_t */

/* TEveProjectionAxes */

/* TEveProjectionAxesEditor */

/* TEveProjectionAxesGL */

/* TEveProjectionManagerEditor */

/* TEveVectorT<float> */

/* TEveVectorT<double> */

/* TEveVector4T<float> */

/* TEveVector4T<double> */

/* TEveVector2T<float> */

/* TEveVector2T<double> */

/* TEveProjection::PreScaleEntry_t */

/* vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> > */

/* vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator */

/* TEveRhoZProjection */

/* TEveRPhiProjection */

/* TEve3DProjection */

/* TEveSceneInfo */

/* TEveTransEditor */

/* TEveSelectorToEventList */

/* TEvePointSelector */

/* TEvePointSelectorConsumer */

/* TEvePathMarkT<float> */

/* TEvePathMarkT<double> */

/* TEveMCTrack */

/* TEveHit */

/* TEveCluster */

/* TEveRecTrack */

/* TEveRecKink */

/* TEveRecV0 */

/* TEveRecCascade */

/* TEveMCRecCrossRef */

/* TEveVSD */

/* TEveWindow */

/* TEveWindowSlot */

/* TEveWindowFrame */

/* TEveWindowPack */

/* TEveWindowTab */

/* TEveCompositeFrame */

/* TEveCompositeFrameInMainFrame */

/* TEveCompositeFrameInPack */

/* TEveCompositeFrameInTab */

/* TEveViewerListEditor */

/* TEveWindowEditor */

/* TEveSecondarySelectable */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__Eve1 {
 public:
  G__Sizep2memfuncG__Eve1(): p(&G__Sizep2memfuncG__Eve1::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__Eve1::*p)();
};

size_t G__get_sizep2memfuncG__Eve1()
{
  G__Sizep2memfuncG__Eve1 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__Eve1() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveException))) {
     TEveException *G__Lderived;
     G__Lderived=(TEveException*)0x1000;
     {
       exception *G__Lpbase=(exception*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveException),G__get_linked_tagnum(&G__G__Eve1LN_exception),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TString *G__Lpbase=(TString*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveException),G__get_linked_tagnum(&G__G__Eve1LN_TString),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveRefBackPtr))) {
     TEveRefBackPtr *G__Lderived;
     G__Lderived=(TEveRefBackPtr*)0x1000;
     {
       TEveRefCnt *G__Lpbase=(TEveRefCnt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRefBackPtr),G__get_linked_tagnum(&G__G__Eve1LN_TEveRefCnt),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager))) {
     TEveProjectionManager *G__Lderived;
     G__Lderived=(TEveProjectionManager*)0x1000;
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager),G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager),G__get_linked_tagnum(&G__G__Eve1LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompound))) {
     TEveCompound *G__Lderived;
     G__Lderived=(TEveCompound*)0x1000;
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompound),G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompound),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompound),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompound),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompound),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveTrans))) {
     TEveTrans *G__Lderived;
     G__Lderived=(TEveTrans*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTrans),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementObjectPtr))) {
     TEveElementObjectPtr *G__Lderived;
     G__Lderived=(TEveElementObjectPtr*)0x1000;
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementObjectPtr),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementObjectPtr),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList))) {
     TEveElementList *G__Lderived;
     G__Lderived=(TEveElementList*)0x1000;
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementListProjected))) {
     TEveElementListProjected *G__Lderived;
     G__Lderived=(TEveElementListProjected*)0x1000;
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementListProjected),G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementListProjected),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementListProjected),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementListProjected),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementListProjected),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjected *G__Lpbase=(TEveProjected*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementListProjected),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjected),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor))) {
     TEveGedEditor *G__Lderived;
     G__Lderived=(TEveGedEditor*)0x1000;
     {
       TGedEditor *G__Lpbase=(TGedEditor*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGedEditor),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualPadEditor *G__Lpbase=(TVirtualPadEditor*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor),G__get_linked_tagnum(&G__G__Eve1LN_TVirtualPadEditor),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveListTreeItem))) {
     TEveListTreeItem *G__Lderived;
     G__Lderived=(TEveListTreeItem*)0x1000;
     {
       TGListTreeItem *G__Lpbase=(TGListTreeItem*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveListTreeItem),G__get_linked_tagnum(&G__G__Eve1LN_TGListTreeItem),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveGListTreeEditorFrame))) {
     TEveGListTreeEditorFrame *G__Lderived;
     G__Lderived=(TEveGListTreeEditorFrame*)0x1000;
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGListTreeEditorFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGListTreeEditorFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGListTreeEditorFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGListTreeEditorFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGListTreeEditorFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGListTreeEditorFrame),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGListTreeEditorFrame),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser))) {
     TEveBrowser *G__Lderived;
     G__Lderived=(TEveBrowser*)0x1000;
     {
       TRootBrowser *G__Lpbase=(TRootBrowser*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser),G__get_linked_tagnum(&G__G__Eve1LN_TRootBrowser),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser),G__get_linked_tagnum(&G__G__Eve1LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TBrowserImp *G__Lpbase=(TBrowserImp*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser),G__get_linked_tagnum(&G__G__Eve1LN_TBrowserImp),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompoundProjected))) {
     TEveCompoundProjected *G__Lderived;
     G__Lderived=(TEveCompoundProjected*)0x1000;
     {
       TEveCompound *G__Lpbase=(TEveCompound*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompoundProjected),G__get_linked_tagnum(&G__G__Eve1LN_TEveCompound),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompoundProjected),G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompoundProjected),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompoundProjected),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompoundProjected),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompoundProjected),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjected *G__Lpbase=(TEveProjected*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompoundProjected),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjected),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TGedEditor))) {
     TGedEditor *G__Lderived;
     G__Lderived=(TGedEditor*)0x1000;
     {
       TVirtualPadEditor *G__Lpbase=(TVirtualPadEditor*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TGedEditor),G__get_linked_tagnum(&G__G__Eve1LN_TVirtualPadEditor),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TGedEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TGedEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TGedEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TGedEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TGedEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TGedEditor),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TGedEditor),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransSubEditor))) {
     TEveTransSubEditor *G__Lderived;
     G__Lderived=(TEveTransSubEditor*)0x1000;
     {
       TGVerticalFrame *G__Lpbase=(TGVerticalFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransSubEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGVerticalFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransSubEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransSubEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransSubEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransSubEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransSubEditor),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransSubEditor),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementEditor))) {
     TEveElementEditor *G__Lderived;
     G__Lderived=(TEveElementEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementEditor),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementEditor),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveEventManager))) {
     TEveEventManager *G__Lderived;
     G__Lderived=(TEveEventManager*)0x1000;
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveEventManager),G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveEventManager),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveEventManager),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveEventManager),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveEventManager),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuatorBase))) {
     TEveGValuatorBase *G__Lderived;
     G__Lderived=(TEveGValuatorBase*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuatorBase),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuatorBase),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuatorBase),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuatorBase),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuatorBase),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuatorBase),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuatorBase),G__get_linked_tagnum(&G__G__Eve1LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator))) {
     TEveGValuator *G__Lderived;
     G__Lderived=(TEveGValuator*)0x1000;
     {
       TEveGValuatorBase *G__Lpbase=(TEveGValuatorBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuatorBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),G__get_linked_tagnum(&G__G__Eve1LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveGDoubleValuator))) {
     TEveGDoubleValuator *G__Lderived;
     G__Lderived=(TEveGDoubleValuator*)0x1000;
     {
       TEveGValuatorBase *G__Lpbase=(TEveGValuatorBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGDoubleValuator),G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuatorBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGDoubleValuator),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGDoubleValuator),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGDoubleValuator),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGDoubleValuator),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGDoubleValuator),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGDoubleValuator),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGDoubleValuator),G__get_linked_tagnum(&G__G__Eve1LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator))) {
     TEveGTriVecValuator *G__Lderived;
     G__Lderived=(TEveGTriVecValuator*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator),G__get_linked_tagnum(&G__G__Eve1LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameFrame))) {
     TEveGedNameFrame *G__Lderived;
     G__Lderived=(TEveGedNameFrame*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameFrame),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameFrame),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameTextButton))) {
     TEveGedNameTextButton *G__Lderived;
     G__Lderived=(TEveGedNameTextButton*)0x1000;
     {
       TGTextButton *G__Lpbase=(TGTextButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameTextButton),G__get_linked_tagnum(&G__G__Eve1LN_TGTextButton),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGButton *G__Lpbase=(TGButton*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameTextButton),G__get_linked_tagnum(&G__G__Eve1LN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameTextButton),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameTextButton),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameTextButton),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameTextButton),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameTextButton),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameTextButton),G__get_linked_tagnum(&G__G__Eve1LN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveMacro))) {
     TEveMacro *G__Lderived;
     G__Lderived=(TEveMacro*)0x1000;
     {
       TMacro *G__Lpbase=(TMacro*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveMacro),G__get_linked_tagnum(&G__G__Eve1LN_TMacro),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveMacro),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveMacro),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection))) {
     TEveSelection *G__Lderived;
     G__Lderived=(TEveSelection*)0x1000;
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection),G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer))) {
     TEveViewer *G__Lderived;
     G__Lderived=(TEveViewer*)0x1000;
     {
       TEveWindowFrame *G__Lpbase=(TEveWindowFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer),G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveWindow *G__Lpbase=(TEveWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer),G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer),G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerList))) {
     TEveViewerList *G__Lderived;
     G__Lderived=(TEveViewerList*)0x1000;
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerList),G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerList),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerList),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerList),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerList),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveScene))) {
     TEveScene *G__Lderived;
     G__Lderived=(TEveScene*)0x1000;
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveScene),G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveScene),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveScene),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveScene),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveScene),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneList))) {
     TEveSceneList *G__Lderived;
     G__Lderived=(TEveSceneList*)0x1000;
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneList),G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneList),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneList),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneList),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneList),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowManager))) {
     TEveWindowManager *G__Lderived;
     G__Lderived=(TEveWindowManager*)0x1000;
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowManager),G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowManager),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowManager),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowManager),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowManager),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowManager),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveManagercLcLTExceptionHandler))) {
     TEveManager::TExceptionHandler *G__Lderived;
     G__Lderived=(TEveManager::TExceptionHandler*)0x1000;
     {
       TStdExceptionHandler *G__Lpbase=(TStdExceptionHandler*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveManagercLcLTExceptionHandler),G__get_linked_tagnum(&G__G__Eve1LN_TStdExceptionHandler),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TSysEvtHandler *G__Lpbase=(TSysEvtHandler*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveManagercLcLTExceptionHandler),G__get_linked_tagnum(&G__G__Eve1LN_TSysEvtHandler),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveManagercLcLTExceptionHandler),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveManagercLcLTExceptionHandler),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEvePad))) {
     TEvePad *G__Lderived;
     G__Lderived=(TEvePad*)0x1000;
     {
       TPad *G__Lpbase=(TPad*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePad),G__get_linked_tagnum(&G__G__Eve1LN_TPad),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualPad *G__Lpbase=(TVirtualPad*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePad),G__get_linked_tagnum(&G__G__Eve1LN_TVirtualPad),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePad),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePad),G__get_linked_tagnum(&G__G__Eve1LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePad),G__get_linked_tagnum(&G__G__Eve1LN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttPad *G__Lpbase=(TAttPad*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePad),G__get_linked_tagnum(&G__G__Eve1LN_TAttPad),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePad),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList))) {
     TEveParamList *G__Lderived;
     G__Lderived=(TEveParamList*)0x1000;
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListEditor))) {
     TEveParamListEditor *G__Lderived;
     G__Lderived=(TEveParamListEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListEditor),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListEditor),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxes))) {
     TEveProjectionAxes *G__Lderived;
     G__Lderived=(TEveProjectionAxes*)0x1000;
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxes),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxes),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxes),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxes),G__get_linked_tagnum(&G__G__Eve1LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxes),G__get_linked_tagnum(&G__G__Eve1LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttAxis *G__Lpbase=(TAttAxis*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxes),G__get_linked_tagnum(&G__G__Eve1LN_TAttAxis),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesEditor))) {
     TEveProjectionAxesEditor *G__Lderived;
     G__Lderived=(TEveProjectionAxesEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesEditor),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesEditor),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesGL))) {
     TEveProjectionAxesGL *G__Lderived;
     G__Lderived=(TEveProjectionAxesGL*)0x1000;
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesGL),G__get_linked_tagnum(&G__G__Eve1LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesGL),G__get_linked_tagnum(&G__G__Eve1LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManagerEditor))) {
     TEveProjectionManagerEditor *G__Lderived;
     G__Lderived=(TEveProjectionManagerEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManagerEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManagerEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManagerEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManagerEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManagerEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManagerEditor),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManagerEditor),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR))) {
     TEveVector4T<float> *G__Lderived;
     G__Lderived=(TEveVector4T<float>*)0x1000;
     {
       TEveVectorT<float> *G__Lpbase=(TEveVectorT<float>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR),G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR))) {
     TEveVector4T<double> *G__Lderived;
     G__Lderived=(TEveVector4T<double>*)0x1000;
     {
       TEveVectorT<double> *G__Lpbase=(TEveVectorT<double>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR),G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveRhoZProjection))) {
     TEveRhoZProjection *G__Lderived;
     G__Lderived=(TEveRhoZProjection*)0x1000;
     {
       TEveProjection *G__Lpbase=(TEveProjection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRhoZProjection),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjection),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveRPhiProjection))) {
     TEveRPhiProjection *G__Lderived;
     G__Lderived=(TEveRPhiProjection*)0x1000;
     {
       TEveProjection *G__Lpbase=(TEveProjection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRPhiProjection),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjection),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEve3DProjection))) {
     TEve3DProjection *G__Lderived;
     G__Lderived=(TEve3DProjection*)0x1000;
     {
       TEveProjection *G__Lpbase=(TEveProjection*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEve3DProjection),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjection),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneInfo))) {
     TEveSceneInfo *G__Lderived;
     G__Lderived=(TEveSceneInfo*)0x1000;
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneInfo),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneInfo),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneInfo),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransEditor))) {
     TEveTransEditor *G__Lderived;
     G__Lderived=(TEveTransEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransEditor),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransEditor),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveSelectorToEventList))) {
     TEveSelectorToEventList *G__Lderived;
     G__Lderived=(TEveSelectorToEventList*)0x1000;
     {
       TSelectorDraw *G__Lpbase=(TSelectorDraw*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSelectorToEventList),G__get_linked_tagnum(&G__G__Eve1LN_TSelectorDraw),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TSelector *G__Lpbase=(TSelector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSelectorToEventList),G__get_linked_tagnum(&G__G__Eve1LN_TSelector),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSelectorToEventList),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelector))) {
     TEvePointSelector *G__Lderived;
     G__Lderived=(TEvePointSelector*)0x1000;
     {
       TSelectorDraw *G__Lpbase=(TSelectorDraw*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelector),G__get_linked_tagnum(&G__G__Eve1LN_TSelectorDraw),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TSelector *G__Lpbase=(TSelector*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelector),G__get_linked_tagnum(&G__G__Eve1LN_TSelector),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelector),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveMCTrack))) {
     TEveMCTrack *G__Lderived;
     G__Lderived=(TEveMCTrack*)0x1000;
     {
       TParticle *G__Lpbase=(TParticle*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveMCTrack),G__get_linked_tagnum(&G__G__Eve1LN_TParticle),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveMCTrack),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveMCTrack),G__get_linked_tagnum(&G__G__Eve1LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveMCTrack),G__get_linked_tagnum(&G__G__Eve1LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveHit))) {
     TEveHit *G__Lderived;
     G__Lderived=(TEveHit*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveHit),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveCluster))) {
     TEveCluster *G__Lderived;
     G__Lderived=(TEveCluster*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCluster),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveRecTrack))) {
     TEveRecTrack *G__Lderived;
     G__Lderived=(TEveRecTrack*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRecTrack),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveRecKink))) {
     TEveRecKink *G__Lderived;
     G__Lderived=(TEveRecKink*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRecKink),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveRecV0))) {
     TEveRecV0 *G__Lderived;
     G__Lderived=(TEveRecV0*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRecV0),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveRecCascade))) {
     TEveRecCascade *G__Lderived;
     G__Lderived=(TEveRecCascade*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRecCascade),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveMCRecCrossRef))) {
     TEveMCRecCrossRef *G__Lderived;
     G__Lderived=(TEveMCRecCrossRef*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveMCRecCrossRef),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveVSD))) {
     TEveVSD *G__Lderived;
     G__Lderived=(TEveVSD*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveVSD),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow))) {
     TEveWindow *G__Lderived;
     G__Lderived=(TEveWindow*)0x1000;
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow),G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot))) {
     TEveWindowSlot *G__Lderived;
     G__Lderived=(TEveWindowSlot*)0x1000;
     {
       TEveWindow *G__Lpbase=(TEveWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot),G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot),G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowFrame))) {
     TEveWindowFrame *G__Lderived;
     G__Lderived=(TEveWindowFrame*)0x1000;
     {
       TEveWindow *G__Lpbase=(TEveWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowFrame),G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowFrame),G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowFrame),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowFrame),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowFrame),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowFrame),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowPack))) {
     TEveWindowPack *G__Lderived;
     G__Lderived=(TEveWindowPack*)0x1000;
     {
       TEveWindow *G__Lpbase=(TEveWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowPack),G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowPack),G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowPack),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowPack),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowPack),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowPack),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowTab))) {
     TEveWindowTab *G__Lderived;
     G__Lderived=(TEveWindowTab*)0x1000;
     {
       TEveWindow *G__Lpbase=(TEveWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowTab),G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowTab),G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowTab),G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowTab),G__get_linked_tagnum(&G__G__Eve1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowTab),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowTab),G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrame))) {
     TEveCompositeFrame *G__Lderived;
     G__Lderived=(TEveCompositeFrame*)0x1000;
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrame),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrame),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInMainFrame))) {
     TEveCompositeFrameInMainFrame *G__Lderived;
     G__Lderived=(TEveCompositeFrameInMainFrame*)0x1000;
     {
       TEveCompositeFrame *G__Lpbase=(TEveCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInMainFrame),G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInMainFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInMainFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInMainFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInMainFrame),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInMainFrame),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInMainFrame),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInPack))) {
     TEveCompositeFrameInPack *G__Lderived;
     G__Lderived=(TEveCompositeFrameInPack*)0x1000;
     {
       TEveCompositeFrame *G__Lpbase=(TEveCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInPack),G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInPack),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInPack),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInPack),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInPack),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInPack),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInPack),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInTab))) {
     TEveCompositeFrameInTab *G__Lderived;
     G__Lderived=(TEveCompositeFrameInTab*)0x1000;
     {
       TEveCompositeFrame *G__Lpbase=(TEveCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInTab),G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInTab),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInTab),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInTab),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInTab),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInTab),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInTab),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerListEditor))) {
     TEveViewerListEditor *G__Lderived;
     G__Lderived=(TEveViewerListEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerListEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerListEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerListEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerListEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerListEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerListEditor),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerListEditor),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowEditor))) {
     TEveWindowEditor *G__Lderived;
     G__Lderived=(TEveWindowEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowEditor),G__get_linked_tagnum(&G__G__Eve1LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowEditor),G__get_linked_tagnum(&G__G__Eve1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowEditor),G__get_linked_tagnum(&G__G__Eve1LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__Eve1() {

   /* 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("Float_t",102,-1,0,-1);
   G__setnewtype(-1,"Float 4 bytes (float)",0);
   G__search_typename2("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Bool_t",103,-1,0,-1);
   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("Option_t",99,-1,256,-1);
   G__setnewtype(-1,"Option string (const char)",0);
   G__search_typename2("Long64_t",110,-1,0,-1);
   G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
   G__search_typename2("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__Eve1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Pixel_t",107,-1,0,-1);
   G__setnewtype(-1,"Pixel value",0);
   G__search_typename2("map<TEveElement*,Int_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TEveElement*,int>",117,G__get_linked_tagnum(&G__G__Eve1LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TEveElement*,int,less<TEveElement*> >",117,G__get_linked_tagnum(&G__G__Eve1LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("RefMap_t",117,G__get_linked_tagnum(&G__G__Eve1LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveRefBackPtr));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("RefMap_i",117,G__get_linked_tagnum(&G__G__Eve1LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveRefBackPtr));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<TEveProjected*>",117,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveProjectedmUcOallocatorlETEveProjectedmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ProjList_t",117,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveProjectedmUcOallocatorlETEveProjectedmUgRsPgR),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ProjList_i",117,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveProjectedmUcOallocatorlETEveProjectedmUgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<TEveElement*>",117,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("key_type",85,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),0,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",85,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),0,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("key_compare",117,G__get_linked_tagnum(&G__G__Eve1LN_lesslETEveElementmUgR),0,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_compare",117,G__get_linked_tagnum(&G__G__Eve1LN_lesslETEveElementmUgR),0,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("allocator_type",117,G__get_linked_tagnum(&G__G__Eve1LN_allocatorlETEveElementmUgR),0,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),2,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),1026,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",85,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),1,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",85,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),1025,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",104,-1,0,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLreverse_iterator),256,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<TEveElement*,less<TEveElement*> >",117,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<TEveListTreeInfo>",117,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<TEveElement::TEveListTreeInfo>",117,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<TEveElement::TEveListTreeInfo,less<TEveElement::TEveListTreeInfo> >",117,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("sLTI_t",117,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgR),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("sLTI_i",117,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("sLTI_ri",117,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgRcLcLreverse_iterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<TEveElement*>",117,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",85,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),0,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("allocator_type",117,G__get_linked_tagnum(&G__G__Eve1LN_allocatorlETEveElementmUgR),0,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("void_pointer",89,-1,0,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),0,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),256,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",85,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),1,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",85,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),257,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",104,-1,0,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLreverse_iterator),256,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("List_t",117,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("List_i",117,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("List_ci",117,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Set_t",117,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Set_i",117,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Set_ci",117,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Select_foo",97,-1,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement));
   G__setnewtype(-1,"void (TEveElement::* Select_foo)      (Bool_t);",0);
   G__search_typename2("ImplySelect_foo",97,-1,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement));
   G__setnewtype(-1,"void (TEveElement::* ImplySelect_foo) ();",0);
   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1LN_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__Eve1LN_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__Eve1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TArrayC*>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETArrayCmUcOallocatorlETArrayCmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETArrayCmUcOallocatorlETArrayCmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETArrayCmUcOallocatorlETArrayCmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETArrayCmUcOallocatorlETArrayCmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETArrayCmUcOallocatorlETArrayCmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<Int_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<int>",117,G__get_linked_tagnum(&G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<int,less<int> >",117,G__get_linked_tagnum(&G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("NameFrameCreator_t",89,-1,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor));
   G__setnewtype(-1,"TGedFrame* (*NameFrameCreator_t)(TEveGedEditor*, const TGWindow* parent, const char* tab_name);",0);
   G__search_typename2("vector<FloatConfig_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEveParamList::FloatConfig_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("FloatConfigVec_t",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgR),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("FloatConfigVec_i",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("FloatConfigVec_ci",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<IntConfig_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEveParamList::IntConfig_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("IntConfigVec_t",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgR),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("IntConfigVec_i",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("IntConfigVec_ci",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<BoolConfig_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEveParamList::BoolConfig_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("BoolConfigVec_t",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgR),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("BoolConfigVec_i",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("BoolConfigVec_ci",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TGNumberEntry*>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETGNumberEntrymUcOallocatorlETGNumberEntrymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETGNumberEntrymUcOallocatorlETGNumberEntrymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETGNumberEntrymUcOallocatorlETGNumberEntrymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETGNumberEntrymUcOallocatorlETGNumberEntrymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETGNumberEntrymUcOallocatorlETGNumberEntrymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TGCheckButton*>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETGCheckButtonmUcOallocatorlETGCheckButtonmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETGCheckButtonmUcOallocatorlETGCheckButtonmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETGCheckButtonmUcOallocatorlETGCheckButtonmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETGCheckButtonmUcOallocatorlETGCheckButtonmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETGCheckButtonmUcOallocatorlETGCheckButtonmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TGLPlane>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETGLPlanecOallocatorlETGLPlanegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETGLPlanecOallocatorlETGLPlanegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Bool_t,TGLLine3>",117,G__get_linked_tagnum(&G__G__Eve1LN_pairlEboolcOTGLLine3gR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Bool_t,TGLVertex3>",117,G__get_linked_tagnum(&G__G__Eve1LN_pairlEboolcOTGLVertex3gR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UChar_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned char>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Int_t,Int_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_pairlEintcOintgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Double_t,Double_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_pairlEdoublecOdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<double>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TGLFont,Int_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TGLFont,int>",117,G__get_linked_tagnum(&G__G__Eve1LN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TGLFont,int,less<TGLFont> >",117,G__get_linked_tagnum(&G__G__Eve1LN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<const TGLFont*>",117,G__get_linked_tagnum(&G__G__Eve1LN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Float_t,Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_pairlEfloatcOfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Lab_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<float,float> >",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Float_t,Int_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_pairlEfloatcOintgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TM_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<float,int> >",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVectorT<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVector",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVectorF",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVectorT<Double_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVectorD",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVector4T<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TP",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVector4",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVector4F",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVector4T<Double_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TP",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVector4D",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVector2T<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVector2",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVector2F",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVector2T<Double_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVector2D",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<PreScaleEntry_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("value_type",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t),256,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t),1,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t),257,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",104,-1,0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pointer",85,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reference",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t),1,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t),1,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("size_type",104,-1,0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEveProjection::PreScaleEntry_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vPreScale_t",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjection));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vPreScale_i",117,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjection));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TEveElement*,Set_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_maplETEveElementmUcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TEveElement*,set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> > >",117,G__get_linked_tagnum(&G__G__Eve1LN_maplETEveElementmUcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TEveElement*,set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >,less<TEveElement*> >",117,G__get_linked_tagnum(&G__G__Eve1LN_maplETEveElementmUcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("SelMap_t",117,G__get_linked_tagnum(&G__G__Eve1LN_maplETEveElementmUcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRsPgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("SelMap_i",117,G__get_linked_tagnum(&G__G__Eve1LN_maplETEveElementmUcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRsPgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TMatrixTBaselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TMatrixTBaselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TMatrixTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TMatrixTRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TMatrixTColumn_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TMatrixTDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TMatrixTFlat_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TMatrixTSub_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TMatrixTSparseRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TMatrixTSparseDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TMatrixTRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TMatrixTColumnlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TMatrixTDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TMatrixTFlatlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TMatrixTSublEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TMatrixTSparseRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TMatrixTSparseDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TElementActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TElementPosActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEvePathMarkT<Float_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEvePathMark",117,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEvePathMarkF",117,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEvePathMarkT<Double_t>",117,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEvePathMarkD",117,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__G__Eve1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__Eve1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__G__Eve1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("IconBarCreator_foo",89,-1,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrame));
   G__setnewtype(-1,"TGFrame* (*IconBarCreator_foo)(TEveCompositeFrame*, TGCompositeFrame*, Int_t);",0);
   G__search_typename2("SelectionSet_t",117,G__get_linked_tagnum(&G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveSecondarySelectable));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("SelectionSet_i",117,G__get_linked_tagnum(&G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveSecondarySelectable));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("SelectionSet_ci",117,G__get_linked_tagnum(&G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve1LN_TEveSecondarySelectable));
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TEveElement */
static void G__setup_memvarTEveElement(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElement));
   { TEveElement *p; p=(TEveElement*)0x1000; if (p) { }
   G__memvar_setup((void*)(&TEveElement::fgRnrIcons),85,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TGPicture),-1,-2,1,"fgRnrIcons[4]=",0,(char*)NULL);
   G__memvar_setup((void*)(&TEveElement::fgListTreeIcons),85,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TGPicture),-1,-2,1,"fgListTreeIcons[9]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR),G__defined_typename("List_t"),-1,2,"fParents=",0,"List of parents.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR),G__defined_typename("List_t"),-1,2,"fChildren=",0,"List of children.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveCompound),-1,-1,2,"fCompound=",0,"Compound this object belongs to.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),-1,-1,2,"fVizModel=",0,"! Element used as model from VizDB.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TString),-1,-1,2,"fVizTag=",0,"Tag used to query VizDB for model element.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumChildren=",0,"!");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fParentIgnoreCnt=",0,"! Counter for parents that are ignored in ref-counting.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTopItemCnt=",0,"! Counter for top-level list-tree items that prevent automatic destruction.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDenyDestroy=",0,"! Deny-destroy count.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDestroyOnZeroRefCnt=",0,"Auto-destruct when ref-count reaches zero.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrSelf=",0,"Render this element.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrChildren=",0,"Render children of this element.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fCanEditMainColor=",0,"Allow editing of main color.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fCanEditMainTransparency=",0,"Allow editing of main transparency.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fCanEditMainTrans=",0,"Allow editing of main transformation.");
   G__memvar_setup((void*)0,99,0,0,-1,G__defined_typename("Char_t"),-1,2,"fMainTransparency=",0,"Main-transparency variable.");
   G__memvar_setup((void*)0,83,0,0,-1,G__defined_typename("Color_t"),-1,2,"fMainColorPtr=",0,"Pointer to main-color variable.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveTrans),-1,-1,2,"fMainTrans=",0,"Pointer to main transformation matrix.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgR),G__defined_typename("sLTI_t"),-1,2,"fItems=",0,"! Set of list-tree-items.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TRef),-1,-1,2,"fSource=",0,"External object that is represented by this element.");
   G__memvar_setup((void*)0,89,0,0,-1,-1,-1,2,"fUserData=",0,"! Externally assigned and controlled user data.");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fPickable=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSelected=",0,"!");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHighlighted=",0,"!");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fImpliedSelected=",0,"!");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fImpliedHighlighted=",0,"!");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLECompoundSelectionColorBits),-1,-2,2,"kCSCBImplySelectAllChildren=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLECompoundSelectionColorBits),-1,-2,2,"kCSCBTakeAnyParentAsMaster=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLECompoundSelectionColorBits),-1,-2,2,"kCSCBApplyMainColorToAllChildren=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLECompoundSelectionColorBits),-1,-2,2,"kCSCBApplyMainColorToMatchingChildren=8LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLECompoundSelectionColorBits),-1,-2,2,"kCSCBApplyMainTransparencyToAllChildren=16LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLECompoundSelectionColorBits),-1,-2,2,"kCSCBApplyMainTransparencyToMatchingChildren=32LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLEDestruct),-1,-2,2,"kNone=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLEDestruct),-1,-2,2,"kStandard=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLEDestruct),-1,-2,2,"kAnnihilate=2LL",0,(char*)NULL);
   G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fCSCBits=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLEChangeBits),-1,-2,1,G__FastAllocString(2048).Format("kCBColorSelection=%lldLL",(long long)TEveElement::kCBColorSelection).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLEChangeBits),-1,-2,1,G__FastAllocString(2048).Format("kCBTransBBox=%lldLL",(long long)TEveElement::kCBTransBBox).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLEChangeBits),-1,-2,1,G__FastAllocString(2048).Format("kCBObjProps=%lldLL",(long long)TEveElement::kCBObjProps).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLEChangeBits),-1,-2,1,G__FastAllocString(2048).Format("kCBVisibility=%lldLL",(long long)TEveElement::kCBVisibility).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fChangeBits=",0,"!");
   G__memvar_setup((void*)0,99,0,0,-1,G__defined_typename("Char_t"),-1,2,"fDestructing=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveUtil */
static void G__setup_memvarTEveUtil(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveUtil));
   { TEveUtil *p; p=(TEveUtil*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TObjArray),-1,-2,4,"fgDefaultColors=",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__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveException */
static void G__setup_memvarTEveException(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveException));
   { TEveException *p; p=(TEveException*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvePadHolder */
static void G__setup_memvarTEvePadHolder(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePadHolder));
   { TEvePadHolder *p; p=(TEvePadHolder*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TVirtualPad),-1,-1,4,"fOldPad=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fModifyUpdateP=",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__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGeoManagerHolder */
static void G__setup_memvarTEveGeoManagerHolder(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGeoManagerHolder));
   { TEveGeoManagerHolder *p; p=(TEveGeoManagerHolder*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGeoManager),-1,-1,4,"fManager=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNSegments=",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__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveRefCnt */
static void G__setup_memvarTEveRefCnt(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRefCnt));
   { TEveRefCnt *p; p=(TEveRefCnt*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRefCount=",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__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveRefBackPtr */
static void G__setup_memvarTEveRefBackPtr(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRefBackPtr));
   { TEveRefBackPtr *p; p=(TEveRefBackPtr*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgR),G__defined_typename("RefMap_t"),-1,2,"fBackRefs=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveProjection */
static void G__setup_memvarTEveProjection(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjection));
   { TEveProjection *p; p=(TEveProjection*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLEPType_e),-1,-2,1,G__FastAllocString(2048).Format("kPT_Unknown=%lldLL",(long long)TEveProjection::kPT_Unknown).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLEPType_e),-1,-2,1,G__FastAllocString(2048).Format("kPT_RPhi=%lldLL",(long long)TEveProjection::kPT_RPhi).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLEPType_e),-1,-2,1,G__FastAllocString(2048).Format("kPT_RhoZ=%lldLL",(long long)TEveProjection::kPT_RhoZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLEPType_e),-1,-2,1,G__FastAllocString(2048).Format("kPT_3D=%lldLL",(long long)TEveProjection::kPT_3D).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLEPType_e),-1,-2,1,G__FastAllocString(2048).Format("kPT_End=%lldLL",(long long)TEveProjection::kPT_End).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLEPProc_e),-1,-2,1,G__FastAllocString(2048).Format("kPP_Plane=%lldLL",(long long)TEveProjection::kPP_Plane).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLEPProc_e),-1,-2,1,G__FastAllocString(2048).Format("kPP_Distort=%lldLL",(long long)TEveProjection::kPP_Distort).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLEPProc_e),-1,-2,1,G__FastAllocString(2048).Format("kPP_Full=%lldLL",(long long)TEveProjection::kPP_Full).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLEGeoMode_e),-1,-2,1,G__FastAllocString(2048).Format("kGM_Unknown=%lldLL",(long long)TEveProjection::kGM_Unknown).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLEGeoMode_e),-1,-2,1,G__FastAllocString(2048).Format("kGM_Polygons=%lldLL",(long long)TEveProjection::kGM_Polygons).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLEGeoMode_e),-1,-2,1,G__FastAllocString(2048).Format("kGM_Segments=%lldLL",(long long)TEveProjection::kGM_Segments).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLEPType_e),-1,-1,2,"fType=",0,"type");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLEGeoMode_e),-1,-1,2,"fGeoMode=",0,"strategy of polygon projection (what to try first)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TString),-1,-1,2,"fName=",0,"name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fCenter=",0,"center of distortion");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fZeroPosVal=",0,"projected origin (0, 0, 0)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUsePreScale=",0,"use pre-scaling");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR),G__defined_typename("vPreScale_t"),-1,2,"fPreScales[3]=",0,"scaling before the distortion");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDistortion=",0,"distortion");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fFixR=",0,"radius from which scaling remains constant");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fFixZ=",0,"z-coordinate from which scaling remains constant");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPastFixRFac=",0,"relative scaling factor beyond fFixR as 10^x");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPastFixZFac=",0,"relative scaling factor beyond fFixZ as 10^x");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fScaleR=",0,"scale factor to keep projected radius at fFixR fixed");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fScaleZ=",0,"scale factor to keep projected z-coordinate at fFixZ fixed");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPastFixRScale=",0,"relative scaling beyond fFixR");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPastFixZScale=",0,"relative scaling beyond fFixZ");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMaxTrackStep=",0,"maximum distance between two points on a track");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fLowLimit=",0,"convergence of point +infinity");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fUpLimit=",0,"convergence of point -infinity");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)(&TEveProjection::fgEps),102,0,0,-1,G__defined_typename("Float_t"),-2,1,"fgEps=",0,"resolution of projected points");
   G__memvar_setup((void*)(&TEveProjection::fgEpsSqr),102,0,0,-1,G__defined_typename("Float_t"),-2,1,"fgEpsSqr=",0,"square of resolution of projected points");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveProjected */
static void G__setup_memvarTEveProjected(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjected));
   { TEveProjected *p; p=(TEveProjected*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager),-1,-1,2,"fManager=",0,"manager");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable),-1,-1,2,"fProjectable=",0,"link to original object");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDepth=",0,"z coordinate");
   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__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveProjectionManager */
static void G__setup_memvarTEveProjectionManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager));
   { TEveProjectionManager *p; p=(TEveProjectionManager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjection),-1,-1,2,"fProjections[4]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjection),-1,-1,2,"fProjection=",0,"current projection");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fCenter=",0,"center of distortion");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fCurrentDepth=",0,"z depth of object being projected");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR),G__defined_typename("List_t"),-1,2,"fDependentEls=",0,"elements that depend on manager and need to be destroyed with it");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fImportEmpty=",0,"import sub-trees with no projectable elements");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveProjectable */
static void G__setup_memvarTEveProjectable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable));
   { TEveProjectable *p; p=(TEveProjectable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_listlETEveProjectedmUcOallocatorlETEveProjectedmUgRsPgR),G__defined_typename("ProjList_t"),-1,2,"fProjectedList=",0,"references to projected instances.");
   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__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> > */
static void G__setup_memvarsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR));
   { set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> > *p; p=(set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator */
static void G__setup_memvarsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator));
   { set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator *p; p=(set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TEveCompound */
static void G__setup_memvarTEveCompound(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompound));
   { TEveCompound *p; p=(TEveCompound*)0x1000; if (p) { }
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fCompoundOpen=",0,"If more than zero, tag new children as compound members.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTrans */
static void G__setup_memvarTEveTrans(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTrans));
   { TEveTrans *p; p=(TEveTrans*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double32_t"),-1,2,"fM[16]=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fA1=",0,"!");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fA2=",0,"!");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fA3=",0,"!");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAsOK=",0,"!");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUseTrans=",0,"use transformation matrix");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEditTrans=",0,"edit transformation in TGedFrame");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEditRotation=",0,"edit rotation");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEditScale=",0,"edit scale");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveManager */
static void G__setup_memvarTEveManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveManager));
   { TEveManager *p; p=(TEveManager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveManagercLcLTExceptionHandler),-1,-1,4,"fExcHandler=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TMap),-1,-1,4,"fVizDB=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fVizDBReplace=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fVizDBUpdate=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TMap),-1,-1,4,"fGeometries=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TMap),-1,-1,4,"fGeometryAliases=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser),-1,-1,4,"fBrowser=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGListTreeEditorFrame),-1,-1,4,"fLTEFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TFolder),-1,-1,4,"fMacroFolder=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowManager),-1,-1,4,"fWindowManager=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerList),-1,-1,4,"fViewers=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneList),-1,-1,4,"fScenes=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveScene),-1,-1,4,"fGlobalScene=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveScene),-1,-1,4,"fEventScene=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveEventManager),-1,-1,4,"fCurrentEvent=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fRedrawDisabled=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFullRedraw=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fResetCameras=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDropLogicals=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fKeepEmptyCont=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTimerActive=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TTimer),-1,-1,4,"fRedrawTimer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TExMap),-1,-1,2,"fStampedElements=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection),-1,-1,2,"fSelection=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection),-1,-1,2,"fHighlight=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList),-1,-1,2,"fOrphanage=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUseOrphanage=",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__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveElement::TEveListTreeInfo */
static void G__setup_memvarTEveElementcLcLTEveListTreeInfo(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLTEveListTreeInfo));
   { TEveElement::TEveListTreeInfo *p; p=(TEveElement::TEveListTreeInfo*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fTree)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGListTree),-1,-1,1,"fTree=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fItem)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGListTreeItem),-1,-1,1,"fItem=",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__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* list<TEveElement*,allocator<TEveElement*> > */
static void G__setup_memvarlistlETEveElementmUcOallocatorlETEveElementmUgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   { list<TEveElement*,allocator<TEveElement*> > *p; p=(list<TEveElement*,allocator<TEveElement*> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* list<TEveElement*,allocator<TEveElement*> >::iterator */
static void G__setup_memvarlistlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator));
   { list<TEveElement*,allocator<TEveElement*> >::iterator *p; p=(list<TEveElement*,allocator<TEveElement*> >::iterator*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TEveElementObjectPtr */
static void G__setup_memvarTEveElementObjectPtr(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementObjectPtr));
   { TEveElementObjectPtr *p; p=(TEveElementObjectPtr*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TObject),-1,-1,2,"fObject=",0,"External object holding the visual data.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOwnObject=",0,"Is object owned / should be deleted on destruction.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveElementList */
static void G__setup_memvarTEveElementList(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList));
   { TEveElementList *p; p=(TEveElementList*)0x1000; if (p) { }
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fColor=",0,"Color of the object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-1,2,"fChildClass=",0,"Class of acceptable children, others are rejected.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveElementListProjected */
static void G__setup_memvarTEveElementListProjected(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementListProjected));
   { TEveElementListProjected *p; p=(TEveElementListProjected*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGedEditor */
static void G__setup_memvarTEveGedEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor));
   { TEveGedEditor *p; p=(TEveGedEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),-1,-1,2,"fElement=",0,"Cached eve-element pointer.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TObject),-1,-1,2,"fObject=",0,"Cached tobj pointer.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgMaxExtraEditors=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TList),-1,-2,2,"fgExtraEditors=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TContextMenu),-1,-2,2,"fgContextMenu=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveListTreeItem */
static void G__setup_memvarTEveListTreeItem(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveListTreeItem));
   { TEveListTreeItem *p; p=(TEveListTreeItem*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),-1,-1,2,"fElement=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGListTreeEditorFrame */
static void G__setup_memvarTEveGListTreeEditorFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGListTreeEditorFrame));
   { TEveGListTreeEditorFrame *p; p=(TEveGListTreeEditorFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),-1,-1,2,"fFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),-1,-1,2,"fLTFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGCanvas),-1,-1,2,"fLTCanvas=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGListTree),-1,-1,2,"fListTree=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGSplitter),-1,-1,2,"fSplitter=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor),-1,-1,2,"fEditor=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TContextMenu),-1,-1,2,"fCtxMenu=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSignalsConnected=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TString),-1,-2,2,"fgEditorClass=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveBrowser */
static void G__setup_memvarTEveBrowser(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser));
   { TEveBrowser *p; p=(TEveBrowser*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGFileBrowser),-1,-1,2,"fFileBrowser=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGPopupMenu),-1,-1,2,"fEvePopup=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGPopupMenu),-1,-1,2,"fSelPopup=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGPopupMenu),-1,-1,2,"fHilPopup=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveChunkManager */
static void G__setup_memvarTEveChunkManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManager));
   { TEveChunkManager *p; p=(TEveChunkManager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fS=",0,"Size of atom");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fN=",0,"Number of atoms in a chunk");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSize=",0,"Size of container, number of atoms");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVecSize=",0,"Number of allocated chunks");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCapacity=",0,"Available capacity within the chunks");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETArrayCmUcOallocatorlETArrayCmUgRsPgR),G__defined_typename("vector<TArrayC*>"),-1,2,"fChunks=",0,"Memory blocks");
   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__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveChunkManager::iterator */
static void G__setup_memvarTEveChunkManagercLcLiterator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManagercLcLiterator));
   { TEveChunkManager::iterator *p; p=(TEveChunkManager::iterator*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fPlex)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManager),-1,-1,1,"fPlex=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fCurrent)-(long)(p)),67,0,0,-1,G__defined_typename("Char_t"),-1,1,"fCurrent=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fAtomIndex)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fAtomIndex=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fNextChunk)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fNextChunk=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fAtomsToGo)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fAtomsToGo=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fSelection)-(long)(p)),85,0,1,G__get_linked_tagnum(&G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR),G__defined_typename("set<Int_t>"),-1,1,"fSelection=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fSelectionIterator)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgRcLcLiterator),G__defined_typename("const_iterator"),-1,1,"fSelectionIterator=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCompoundProjected */
static void G__setup_memvarTEveCompoundProjected(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompoundProjected));
   { TEveCompoundProjected *p; p=(TEveCompoundProjected*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTransSubEditor */
static void G__setup_memvarTEveTransSubEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransSubEditor));
   { TEveTransSubEditor *p; p=(TEveTransSubEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveTrans),-1,-1,2,"fTrans=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGHorizontalFrame),-1,-1,2,"fTopHorFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGCheckButton),-1,-1,2,"fUseTrans=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGCheckButton),-1,-1,2,"fEditTrans=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGVerticalFrame),-1,-1,2,"fEditTransFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator),-1,-1,2,"fPos=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator),-1,-1,2,"fRot=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator),-1,-1,2,"fScale=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGCheckButton),-1,-1,2,"fAutoUpdate=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGTextButton),-1,-1,2,"fUpdate=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveElementEditor */
static void G__setup_memvarTEveElementEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementEditor));
   { TEveElementEditor *p; p=(TEveElementEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),-1,-1,2,"fRE=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGHorizontalFrame),-1,-1,2,"fHFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGLabel),-1,-1,2,"fPreLabel=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGCheckButton),-1,-1,2,"fRnrSelf=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGCheckButton),-1,-1,2,"fRnrChildren=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGCheckButton),-1,-1,2,"fRnrState=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGColorSelect),-1,-1,2,"fMainColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGNumberEntry),-1,-1,2,"fTransparency=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveTransSubEditor),-1,-1,2,"fTrans=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveEventManager */
static void G__setup_memvarTEveEventManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveEventManager));
   { TEveEventManager *p; p=(TEveEventManager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETStringcOallocatorlETStringgRsPgR),G__defined_typename("vector<TString>"),-1,2,"fNewEventCommands=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGValuatorBase */
static void G__setup_memvarTEveGValuatorBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuatorBase));
   { TEveGValuatorBase *p; p=(TEveGValuatorBase*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fLabelWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAlignRight=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowSlider=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNELength=",0,"Number-entry length (in characters)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNEHeight=",0,"Number-entry height (in pixels)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGLabel),-1,-1,2,"fLabel=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGValuator */
static void G__setup_memvarTEveGValuator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator));
   { TEveGValuator *p; p=(TEveGValuator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fValue=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMax=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSliderNewLine=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSliderDivs=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGNumberEntry),-1,-1,2,"fEntry=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGHSlider),-1,-1,2,"fSlider=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGDoubleValuator */
static void G__setup_memvarTEveGDoubleValuator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGDoubleValuator));
   { TEveGDoubleValuator *p; p=(TEveGDoubleValuator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGNumberEntry),-1,-1,2,"fMinEntry=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGNumberEntry),-1,-1,2,"fMaxEntry=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGDoubleHSlider),-1,-1,2,"fSlider=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGTriVecValuator */
static void G__setup_memvarTEveGTriVecValuator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator));
   { TEveGTriVecValuator *p; p=(TEveGTriVecValuator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),-1,-1,2,"fVal[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fLabelWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNELength=",0,"Number-entry length (in characters)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNEHeight=",0,"Number-entry height (in pixels)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGedNameFrame */
static void G__setup_memvarTEveGedNameFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameFrame));
   { TEveGedNameFrame *p; p=(TEveGedNameFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGTextButton),-1,-1,2,"fNCButton=",0,"Name/Class button.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGedNameTextButton */
static void G__setup_memvarTEveGedNameTextButton(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameTextButton));
   { TEveGedNameTextButton *p; p=(TEveGedNameTextButton*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameFrame),-1,-1,4,"fFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveMacro */
static void G__setup_memvarTEveMacro(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveMacro));
   { TEveMacro *p; p=(TEveMacro*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveSelection */
static void G__setup_memvarTEveSelection(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection));
   { TEveSelection *p; p=(TEveSelection*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveSelectioncLcLEPickToSelect),-1,-2,1,G__FastAllocString(2048).Format("kPS_Ignore=%lldLL",(long long)TEveSelection::kPS_Ignore).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveSelectioncLcLEPickToSelect),-1,-2,1,G__FastAllocString(2048).Format("kPS_Element=%lldLL",(long long)TEveSelection::kPS_Element).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveSelectioncLcLEPickToSelect),-1,-2,1,G__FastAllocString(2048).Format("kPS_Projectable=%lldLL",(long long)TEveSelection::kPS_Projectable).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveSelectioncLcLEPickToSelect),-1,-2,1,G__FastAllocString(2048).Format("kPS_Compound=%lldLL",(long long)TEveSelection::kPS_Compound).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveSelectioncLcLEPickToSelect),-1,-2,1,G__FastAllocString(2048).Format("kPS_PableCompound=%lldLL",(long long)TEveSelection::kPS_PableCompound).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveSelectioncLcLEPickToSelect),-1,-2,1,G__FastAllocString(2048).Format("kPS_Master=%lldLL",(long long)TEveSelection::kPS_Master).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPickToSelect=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fActive=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsMaster=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_maplETEveElementmUcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRsPgRsPgRsPgR),G__defined_typename("SelMap_t"),-1,2,"fImpliedSelected=",0,(char*)NULL);
   G__memvar_setup((void*)0,97,0,0,-1,G__defined_typename("Select_foo"),-1,2,"fSelElement=",0,(char*)NULL);
   G__memvar_setup((void*)0,97,0,0,-1,G__defined_typename("ImplySelect_foo"),-1,2,"fIncImpSelElement=",0,(char*)NULL);
   G__memvar_setup((void*)0,97,0,0,-1,G__defined_typename("ImplySelect_foo"),-1,2,"fDecImpSelElement=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveViewer */
static void G__setup_memvarTEveViewer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer));
   { TEveViewer *p; p=(TEveViewer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGLViewer),-1,-1,2,"fGLViewer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),-1,-1,2,"fGLViewerFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgInitInternal=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgRecreateGlOnDockOps=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveViewerList */
static void G__setup_memvarTEveViewerList(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerList));
   { TEveViewerList *p; p=(TEveViewerList*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowTooltip=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fBrightness=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUseLightColorSet=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveScene */
static void G__setup_memvarTEveScene(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveScene));
   { TEveScene *p; p=(TEveScene*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEvePad),-1,-1,2,"fPad=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGLScenePad),-1,-1,2,"fGLScene=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fChanged=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSmartRefresh=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHierarchical=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveSceneList */
static void G__setup_memvarTEveSceneList(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneList));
   { TEveSceneList *p; p=(TEveSceneList*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveWindowManager */
static void G__setup_memvarTEveWindowManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowManager));
   { TEveWindowManager *p; p=(TEveWindowManager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow),-1,-1,2,"fCurrentWindow=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow),-1,-1,2,"fDefaultContainer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveManager::TRedrawDisabler */
static void G__setup_memvarTEveManagercLcLTRedrawDisabler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveManagercLcLTRedrawDisabler));
   { TEveManager::TRedrawDisabler *p; p=(TEveManager::TRedrawDisabler*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveManager),-1,-1,4,"fMgr=",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__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveManager::TExceptionHandler */
static void G__setup_memvarTEveManagercLcLTExceptionHandler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveManagercLcLTExceptionHandler));
   { TEveManager::TExceptionHandler *p; p=(TEveManager::TExceptionHandler*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvePad */
static void G__setup_memvarTEvePad(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePad));
   { TEvePad *p; p=(TEvePad*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveParamList */
static void G__setup_memvarTEveParamList(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList));
   { TEveParamList *p; p=(TEveParamList*)0x1000; if (p) { }
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgR),G__defined_typename("FloatConfigVec_t"),-1,2,"fFloatParameters=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgR),G__defined_typename("IntConfigVec_t"),-1,2,"fIntParameters=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgR),G__defined_typename("BoolConfigVec_t"),-1,2,"fBoolParameters=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveParamListEditor */
static void G__setup_memvarTEveParamListEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListEditor));
   { TEveParamListEditor *p; p=(TEveParamListEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGVerticalFrame),-1,-1,2,"fParamFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETGNumberEntrymUcOallocatorlETGNumberEntrymUgRsPgR),G__defined_typename("vector<TGNumberEntry*>"),-1,2,"fIntParameters=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETGNumberEntrymUcOallocatorlETGNumberEntrymUgRsPgR),G__defined_typename("vector<TGNumberEntry*>"),-1,2,"fFloatParameters=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_vectorlETGCheckButtonmUcOallocatorlETGCheckButtonmUgRsPgR),G__defined_typename("vector<TGCheckButton*>"),-1,2,"fBoolParameters=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveParamList::FloatConfig_t */
static void G__setup_memvarTEveParamListcLcLFloatConfig_t(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLFloatConfig_t));
   { TEveParamList::FloatConfig_t *p; p=(TEveParamList::FloatConfig_t*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fValue)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fValue=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fMin)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fMin=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fMax)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fMax=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fName)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TString),-1,-1,1,"fName=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fSelector)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fSelector=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveParamList::IntConfig_t */
static void G__setup_memvarTEveParamListcLcLIntConfig_t(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLIntConfig_t));
   { TEveParamList::IntConfig_t *p; p=(TEveParamList::IntConfig_t*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fValue)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fValue=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fMin)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fMin=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fMax)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fMax=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fName)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TString),-1,-1,1,"fName=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fSelector)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fSelector=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveParamList::BoolConfig_t */
static void G__setup_memvarTEveParamListcLcLBoolConfig_t(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLBoolConfig_t));
   { TEveParamList::BoolConfig_t *p; p=(TEveParamList::BoolConfig_t*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fValue)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fValue=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fName)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TString),-1,-1,1,"fName=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveProjectionAxes */
static void G__setup_memvarTEveProjectionAxes(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxes));
   { TEveProjectionAxes *p; p=(TEveProjectionAxes*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxescLcLELabMode),-1,-2,1,G__FastAllocString(2048).Format("kPosition=%lldLL",(long long)TEveProjectionAxes::kPosition).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxescLcLELabMode),-1,-2,1,G__FastAllocString(2048).Format("kValue=%lldLL",(long long)TEveProjectionAxes::kValue).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxescLcLEAxesMode),-1,-2,1,G__FastAllocString(2048).Format("kHorizontal=%lldLL",(long long)TEveProjectionAxes::kHorizontal).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxescLcLEAxesMode),-1,-2,1,G__FastAllocString(2048).Format("kVertical=%lldLL",(long long)TEveProjectionAxes::kVertical).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxescLcLEAxesMode),-1,-2,1,G__FastAllocString(2048).Format("kAll=%lldLL",(long long)TEveProjectionAxes::kAll).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager),-1,-1,2,"fManager=",0,"Model object.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fUseColorSet=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxescLcLELabMode),-1,-1,2,"fLabMode=",0,"Division of distorted space.");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxescLcLEAxesMode),-1,-1,2,"fAxesMode=",0,"Axis vertical/hotrizontal orientation.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDrawCenter=",0,"Draw center of distortion.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDrawOrigin=",0,"Draw origin.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveProjectionAxesEditor */
static void G__setup_memvarTEveProjectionAxesEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesEditor));
   { TEveProjectionAxesEditor *p; p=(TEveProjectionAxesEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxes),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGComboBox),-1,-1,2,"fLabMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGComboBox),-1,-1,2,"fAxesMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGVerticalFrame),-1,-1,2,"fCenterFrame=",0,"Parent frame for Center tab.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGCheckButton),-1,-1,2,"fDrawCenter=",0,"draw center widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGCheckButton),-1,-1,2,"fDrawOrigin=",0,"draw origin widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveProjectionAxesGL */
static void G__setup_memvarTEveProjectionAxesGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesGL));
   { TEveProjectionAxesGL *p; p=(TEveProjectionAxesGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxes),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjection),-1,-1,2,"fProjection=",0,"Cached model projection");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGLAxisPainter),-1,-1,2,"fAxisPainter=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveProjectionManagerEditor */
static void G__setup_memvarTEveProjectionManagerEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManagerEditor));
   { TEveProjectionManagerEditor *p; p=(TEveProjectionManagerEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGComboBox),-1,-1,2,"fType=",0,"TEveProjection type widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),-1,-1,2,"fDistortion=",0,"TEveProjection distortion widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),-1,-1,2,"fFixR=",0,"TEveProjection fixed-radius widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),-1,-1,2,"fFixZ=",0,"TEveProjection fixed-z widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),-1,-1,2,"fPastFixRFac=",0,"TEveProjection relative scale after FixR");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),-1,-1,2,"fPastFixZFac=",0,"TEveProjection relative scale after FixZ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),-1,-1,2,"fCurrentDepth=",0,"TEveProjection z-coordinate widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),-1,-1,2,"fMaxTrackStep=",0,"TEveProjection relative scale after FixZ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGVerticalFrame),-1,-1,2,"fCenterFrame=",0,"parent frame for distortion center");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),-1,-1,2,"fCenterX=",0,"center x value widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),-1,-1,2,"fCenterY=",0,"center y value widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),-1,-1,2,"fCenterZ=",0,"center z value widget");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveVectorT<float> */
static void G__setup_memvarTEveVectorTlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR));
   { TEveVectorT<float> *p; p=(TEveVectorT<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fX)-(long)(p)),102,0,0,-1,-1,-1,1,"fX=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fY)-(long)(p)),102,0,0,-1,-1,-1,1,"fY=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fZ)-(long)(p)),102,0,0,-1,-1,-1,1,"fZ=",0,"Components of the vector.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveVectorT<double> */
static void G__setup_memvarTEveVectorTlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR));
   { TEveVectorT<double> *p; p=(TEveVectorT<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fX)-(long)(p)),100,0,0,-1,-1,-1,1,"fX=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fY)-(long)(p)),100,0,0,-1,-1,-1,1,"fY=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fZ)-(long)(p)),100,0,0,-1,-1,-1,1,"fZ=",0,"Components of the vector.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveVector4T<float> */
static void G__setup_memvarTEveVector4TlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR));
   { TEveVector4T<float> *p; p=(TEveVector4T<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fT)-(long)(p)),102,0,0,-1,-1,-1,1,"fT=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveVector4T<double> */
static void G__setup_memvarTEveVector4TlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR));
   { TEveVector4T<double> *p; p=(TEveVector4T<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fT)-(long)(p)),100,0,0,-1,-1,-1,1,"fT=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveVector2T<float> */
static void G__setup_memvarTEveVector2TlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR));
   { TEveVector2T<float> *p; p=(TEveVector2T<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fX)-(long)(p)),102,0,0,-1,-1,-1,1,"fX=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fY)-(long)(p)),102,0,0,-1,-1,-1,1,"fY=",0,"Components of the point.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveVector2T<double> */
static void G__setup_memvarTEveVector2TlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR));
   { TEveVector2T<double> *p; p=(TEveVector2T<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fX)-(long)(p)),100,0,0,-1,-1,-1,1,"fX=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fY)-(long)(p)),100,0,0,-1,-1,-1,1,"fY=",0,"Components of the point.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveProjection::PreScaleEntry_t */
static void G__setup_memvarTEveProjectioncLcLPreScaleEntry_t(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t));
   { TEveProjection::PreScaleEntry_t *p; p=(TEveProjection::PreScaleEntry_t*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fMin)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fMin=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fMax)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fMax=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fOffset)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fOffset=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fScale)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fScale=",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__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> > */
static void G__setup_memvarvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   { vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> > *p; p=(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator */
static void G__setup_memvarvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator));
   { vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator *p; p=(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TEveRhoZProjection */
static void G__setup_memvarTEveRhoZProjection(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRhoZProjection));
   { TEveRhoZProjection *p; p=(TEveRhoZProjection*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,4,"fProjectedCenter=",0,"projected center of distortion.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveRPhiProjection */
static void G__setup_memvarTEveRPhiProjection(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRPhiProjection));
   { TEveRPhiProjection *p; p=(TEveRPhiProjection*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEve3DProjection */
static void G__setup_memvarTEve3DProjection(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEve3DProjection));
   { TEve3DProjection *p; p=(TEve3DProjection*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveSceneInfo */
static void G__setup_memvarTEveSceneInfo(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneInfo));
   { TEveSceneInfo *p; p=(TEveSceneInfo*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer),-1,-1,2,"fViewer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveScene),-1,-1,2,"fScene=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGLSceneInfo),-1,-1,2,"fGLSceneInfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTransEditor */
static void G__setup_memvarTEveTransEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransEditor));
   { TEveTransEditor *p; p=(TEveTransEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveTrans),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveTransSubEditor),-1,-1,2,"fSE=",0,"Actual editor widget.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveSelectorToEventList */
static void G__setup_memvarTEveSelectorToEventList(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSelectorToEventList));
   { TEveSelectorToEventList *p; p=(TEveSelectorToEventList*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEventList),-1,-1,2,"fEvList=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TList),-1,-1,2,"fInput=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvePointSelector */
static void G__setup_memvarTEvePointSelector(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelector));
   { TEvePointSelector *p; p=(TEvePointSelector*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TTree),-1,-1,2,"fTree=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelectorConsumer),-1,-1,2,"fConsumer=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TString),-1,-1,2,"fVarexp=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TString),-1,-1,2,"fSelection=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TString),-1,-1,2,"fSubIdExp=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSubIdNum=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TList),-1,-1,2,"fInput=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvePointSelectorConsumer */
static void G__setup_memvarTEvePointSelectorConsumer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelectorConsumer));
   { TEvePointSelectorConsumer *p; p=(TEvePointSelectorConsumer*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelectorConsumercLcLETreeVarType_e),-1,-2,1,G__FastAllocString(2048).Format("kTVT_XYZ=%lldLL",(long long)TEvePointSelectorConsumer::kTVT_XYZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelectorConsumercLcLETreeVarType_e),-1,-2,1,G__FastAllocString(2048).Format("kTVT_RPhiZ=%lldLL",(long long)TEvePointSelectorConsumer::kTVT_RPhiZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelectorConsumercLcLETreeVarType_e),-1,-1,2,"fSourceCS=",0,"Coordinate-System of the source tree variables");
   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__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvePathMarkT<float> */
static void G__setup_memvarTEvePathMarkTlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgR));
   { TEvePathMarkT<float> *p; p=(TEvePathMarkT<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgRcLcLEType_e),-1,-2,1,G__FastAllocString(2048).Format("kReference=%lldLL",(long long)TEvePathMarkT<float>::kReference).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgRcLcLEType_e),-1,-2,1,G__FastAllocString(2048).Format("kDaughter=%lldLL",(long long)TEvePathMarkT<float>::kDaughter).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgRcLcLEType_e),-1,-2,1,G__FastAllocString(2048).Format("kDecay=%lldLL",(long long)TEvePathMarkT<float>::kDecay).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgRcLcLEType_e),-1,-2,1,G__FastAllocString(2048).Format("kCluster2D=%lldLL",(long long)TEvePathMarkT<float>::kCluster2D).data(),0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fType)-(long)(p)),105,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgRcLcLEType_e),-1,-1,1,"fType=",0,"Mark-type.");
   G__memvar_setup((void*)((long)(&p->fV)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),-1,-1,1,"fV=",0,"Vertex.");
   G__memvar_setup((void*)((long)(&p->fP)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),-1,-1,1,"fP=",0,"Momentum.");
   G__memvar_setup((void*)((long)(&p->fE)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),-1,-1,1,"fE=",0,"Extra, meaning depends on fType.");
   G__memvar_setup((void*)((long)(&p->fTime)-(long)(p)),102,0,0,-1,-1,-1,1,"fTime=",0,"Time.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvePathMarkT<double> */
static void G__setup_memvarTEvePathMarkTlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegR));
   { TEvePathMarkT<double> *p; p=(TEvePathMarkT<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegRcLcLEType_e),-1,-2,1,G__FastAllocString(2048).Format("kReference=%lldLL",(long long)TEvePathMarkT<double>::kReference).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegRcLcLEType_e),-1,-2,1,G__FastAllocString(2048).Format("kDaughter=%lldLL",(long long)TEvePathMarkT<double>::kDaughter).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegRcLcLEType_e),-1,-2,1,G__FastAllocString(2048).Format("kDecay=%lldLL",(long long)TEvePathMarkT<double>::kDecay).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegRcLcLEType_e),-1,-2,1,G__FastAllocString(2048).Format("kCluster2D=%lldLL",(long long)TEvePathMarkT<double>::kCluster2D).data(),0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fType)-(long)(p)),105,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegRcLcLEType_e),-1,-1,1,"fType=",0,"Mark-type.");
   G__memvar_setup((void*)((long)(&p->fV)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR),-1,-1,1,"fV=",0,"Vertex.");
   G__memvar_setup((void*)((long)(&p->fP)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR),-1,-1,1,"fP=",0,"Momentum.");
   G__memvar_setup((void*)((long)(&p->fE)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR),-1,-1,1,"fE=",0,"Extra, meaning depends on fType.");
   G__memvar_setup((void*)((long)(&p->fTime)-(long)(p)),100,0,0,-1,-1,-1,1,"fTime=",0,"Time.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveMCTrack */
static void G__setup_memvarTEveMCTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveMCTrack));
   { TEveMCTrack *p; p=(TEveMCTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fLabel)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fLabel=",0,"Label of the track");
   G__memvar_setup((void*)((long)(&p->fIndex)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fIndex=",0,"Index of the track (in some source array)");
   G__memvar_setup((void*)((long)(&p->fEvaLabel)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fEvaLabel=",0,"Label of primary particle");
   G__memvar_setup((void*)((long)(&p->fDecayed)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fDecayed=",0,"True if decayed during tracking.");
   G__memvar_setup((void*)((long)(&p->fTDecay)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fTDecay=",0,"Decay time");
   G__memvar_setup((void*)((long)(&p->fVDecay)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fVDecay=",0,"Decay vertex");
   G__memvar_setup((void*)((long)(&p->fPDecay)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fPDecay=",0,"Decay momentum");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveHit */
static void G__setup_memvarTEveHit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveHit));
   { TEveHit *p; p=(TEveHit*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fDetId)-(long)(p)),114,0,0,-1,G__defined_typename("UShort_t"),-1,1,"fDetId=",0,"Custom detector id.");
   G__memvar_setup((void*)((long)(&p->fSubdetId)-(long)(p)),114,0,0,-1,G__defined_typename("UShort_t"),-1,1,"fSubdetId=",0,"Custom sub-detector id.");
   G__memvar_setup((void*)((long)(&p->fLabel)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fLabel=",0,"Label of particle that produced the hit.");
   G__memvar_setup((void*)((long)(&p->fEvaLabel)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fEvaLabel=",0,"Label of primary particle, ancestor of label.");
   G__memvar_setup((void*)((long)(&p->fV)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fV=",0,"Hit position.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCluster */
static void G__setup_memvarTEveCluster(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCluster));
   { TEveCluster *p; p=(TEveCluster*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fDetId)-(long)(p)),114,0,0,-1,G__defined_typename("UShort_t"),-1,1,"fDetId=",0,"Custom detector id.");
   G__memvar_setup((void*)((long)(&p->fSubdetId)-(long)(p)),114,0,0,-1,G__defined_typename("UShort_t"),-1,1,"fSubdetId=",0,"Custom sub-detector id.");
   G__memvar_setup((void*)((long)(&p->fLabel)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fLabel[3]=",0,"Labels of particles that contributed hits.");
   G__memvar_setup((void*)((long)(&p->fV)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fV=",0,"Vertex.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveRecTrack */
static void G__setup_memvarTEveRecTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRecTrack));
   { TEveRecTrack *p; p=(TEveRecTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fLabel)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fLabel=",0,"Label of the track.");
   G__memvar_setup((void*)((long)(&p->fIndex)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fIndex=",0,"Index of the track (in some source array).");
   G__memvar_setup((void*)((long)(&p->fStatus)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fStatus=",0,"Status as exported from reconstruction.");
   G__memvar_setup((void*)((long)(&p->fSign)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fSign=",0,"Charge of the track.");
   G__memvar_setup((void*)((long)(&p->fV)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fV=",0,"Start vertex from reconstruction.");
   G__memvar_setup((void*)((long)(&p->fP)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fP=",0,"Reconstructed momentum at start vertex.");
   G__memvar_setup((void*)((long)(&p->fBeta)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fBeta=",0,"Relativistic beta factor.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveRecKink */
static void G__setup_memvarTEveRecKink(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRecKink));
   { TEveRecKink *p; p=(TEveRecKink*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fVKink)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fVKink=",0,"Kink vertex: reconstructed position of the kink");
   G__memvar_setup((void*)((long)(&p->fPMother)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fPMother=",0,"Momentum of the mother track");
   G__memvar_setup((void*)((long)(&p->fVMother)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fVMother=",0,"Vertex of the mother track");
   G__memvar_setup((void*)((long)(&p->fPDaughter)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fPDaughter=",0,"Momentum of the daughter track");
   G__memvar_setup((void*)((long)(&p->fVDaughter)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fVDaughter=",0,"Vertex of the daughter track");
   G__memvar_setup((void*)((long)(&p->fKinkAngle)-(long)(p)),100,0,0,-1,G__defined_typename("Double32_t"),-1,1,"fKinkAngle[3]=",0,"three angles");
   G__memvar_setup((void*)((long)(&p->fSign)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fSign=",0,"sign of the track");
   G__memvar_setup((void*)((long)(&p->fStatus)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fStatus=",0,"Status as exported from reconstruction");
   G__memvar_setup((void*)((long)(&p->fKinkLabel)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fKinkLabel[2]=",0,"Labels of the mother and daughter tracks");
   G__memvar_setup((void*)((long)(&p->fKinkIndex)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fKinkIndex[2]=",0,"Indices of the mother and daughter tracks");
   G__memvar_setup((void*)((long)(&p->fKinkPdg)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fKinkPdg[2]=",0,"PDG code of mother and daughter.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveRecV0 */
static void G__setup_memvarTEveRecV0(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRecV0));
   { TEveRecV0 *p; p=(TEveRecV0*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fStatus)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fStatus=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fVNeg)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fVNeg=",0,"Vertex of negative track.");
   G__memvar_setup((void*)((long)(&p->fPNeg)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fPNeg=",0,"Momentum of negative track.");
   G__memvar_setup((void*)((long)(&p->fVPos)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fVPos=",0,"Vertex of positive track.");
   G__memvar_setup((void*)((long)(&p->fPPos)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fPPos=",0,"Momentum of positive track.");
   G__memvar_setup((void*)((long)(&p->fVCa)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fVCa=",0,"Point of closest approach.");
   G__memvar_setup((void*)((long)(&p->fV0Birth)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fV0Birth=",0,"Reconstucted birth point of neutral particle.");
   G__memvar_setup((void*)((long)(&p->fLabel)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fLabel=",0,"Neutral mother label read from kinematics.");
   G__memvar_setup((void*)((long)(&p->fPdg)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fPdg=",0,"PDG code of mother.");
   G__memvar_setup((void*)((long)(&p->fDLabel)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fDLabel[2]=",0,"Daughter labels.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveRecCascade */
static void G__setup_memvarTEveRecCascade(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRecCascade));
   { TEveRecCascade *p; p=(TEveRecCascade*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fStatus)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fStatus=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fVBac)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fVBac=",0,"Vertex of bachelor track.");
   G__memvar_setup((void*)((long)(&p->fPBac)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fPBac=",0,"Momentum of bachelor track.");
   G__memvar_setup((void*)((long)(&p->fCascadeVCa)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fCascadeVCa=",0,"Point of closest approach for Cascade.");
   G__memvar_setup((void*)((long)(&p->fCascadeBirth)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,1,"fCascadeBirth=",0,"Reconstucted birth point of cascade particle.");
   G__memvar_setup((void*)((long)(&p->fLabel)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fLabel=",0,"Cascade mother label read from kinematics.");
   G__memvar_setup((void*)((long)(&p->fPdg)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fPdg=",0,"PDG code of mother.");
   G__memvar_setup((void*)((long)(&p->fDLabel)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fDLabel=",0,"Daughter label.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveMCRecCrossRef */
static void G__setup_memvarTEveMCRecCrossRef(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveMCRecCrossRef));
   { TEveMCRecCrossRef *p; p=(TEveMCRecCrossRef*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fIsRec)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fIsRec=",0,"Is reconstructed.");
   G__memvar_setup((void*)((long)(&p->fHasV0)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fHasV0=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fHasKink)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fHasKink=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fLabel)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fLabel=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fNHits)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fNHits=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fNClus)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fNClus=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveVSD */
static void G__setup_memvarTEveVSD(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveVSD));
   { TEveVSD *p; p=(TEveVSD*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TFile),-1,-1,2,"fFile=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TDirectory),-1,-1,2,"fDirectory=",0,"!");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBuffSize=",0,"!");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVerbose=",0,"!");
   G__memvar_setup((void*)((long)(&p->fTreeK)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TTree),-1,-1,1,"fTreeK=",0,"! Kinematics.");
   G__memvar_setup((void*)((long)(&p->fTreeH)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TTree),-1,-1,1,"fTreeH=",0,"! Hits.");
   G__memvar_setup((void*)((long)(&p->fTreeC)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TTree),-1,-1,1,"fTreeC=",0,"! Clusters.");
   G__memvar_setup((void*)((long)(&p->fTreeR)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TTree),-1,-1,1,"fTreeR=",0,"! Reconstructed tracks.");
   G__memvar_setup((void*)((long)(&p->fTreeKK)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TTree),-1,-1,1,"fTreeKK=",0,"! Kinks.");
   G__memvar_setup((void*)((long)(&p->fTreeV0)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TTree),-1,-1,1,"fTreeV0=",0,"! VO's.");
   G__memvar_setup((void*)((long)(&p->fTreeCC)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TTree),-1,-1,1,"fTreeCC=",0,"! Cascades.");
   G__memvar_setup((void*)((long)(&p->fTreeGI)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TTree),-1,-1,1,"fTreeGI=",0,"! Sim-Rec cross references.");
   G__memvar_setup((void*)((long)(&p->fK)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveMCTrack),-1,-1,1,"fK=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fpK)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveMCTrack),-1,-1,1,"fpK=",0,"!");
   G__memvar_setup((void*)((long)(&p->fH)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveHit),-1,-1,1,"fH=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fpH)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveHit),-1,-1,1,"fpH=",0,"!");
   G__memvar_setup((void*)((long)(&p->fC)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveCluster),-1,-1,1,"fC=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fpC)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveCluster),-1,-1,1,"fpC=",0,"!");
   G__memvar_setup((void*)((long)(&p->fR)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveRecTrack),-1,-1,1,"fR=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fpR)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveRecTrack),-1,-1,1,"fpR=",0,"!");
   G__memvar_setup((void*)((long)(&p->fKK)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveRecKink),-1,-1,1,"fKK=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fpKK)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveRecKink),-1,-1,1,"fpKK=",0,"!");
   G__memvar_setup((void*)((long)(&p->fV0)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveRecV0),-1,-1,1,"fV0=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fpV0)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveRecV0),-1,-1,1,"fpV0=",0,"!");
   G__memvar_setup((void*)((long)(&p->fCC)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveRecCascade),-1,-1,1,"fCC=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fpCC)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveRecCascade),-1,-1,1,"fpCC=",0,"!");
   G__memvar_setup((void*)((long)(&p->fGI)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveMCRecCrossRef),-1,-1,1,"fGI=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fpGI)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveMCRecCrossRef),-1,-1,1,"fpGI=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveWindow */
static void G__setup_memvarTEveWindow(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow));
   { TEveWindow *p; p=(TEveWindow*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrame),-1,-1,2,"fEveFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowTitleBar=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,2,"fgMainFrameDefWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,2,"fgMainFrameDefHeight=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-2,2,"fgCurrentBackgroundColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,107,0,0,-1,G__defined_typename("Pixel_t"),-2,2,"fgMiniBarBackgroundColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveWindowSlot */
static void G__setup_memvarTEveWindowSlot(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot));
   { TEveWindowSlot *p; p=(TEveWindowSlot*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGTextButton),-1,-1,2,"fEmptyButt=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),-1,-1,2,"fEmbedBuffer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveWindowFrame */
static void G__setup_memvarTEveWindowFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowFrame));
   { TEveWindowFrame *p; p=(TEveWindowFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),-1,-1,2,"fGUIFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveWindowPack */
static void G__setup_memvarTEveWindowPack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowPack));
   { TEveWindowPack *p; p=(TEveWindowPack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGPack),-1,-1,2,"fPack=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveWindowTab */
static void G__setup_memvarTEveWindowTab(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowTab));
   { TEveWindowTab *p; p=(TEveWindowTab*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGTab),-1,-1,2,"fTab=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCompositeFrame */
static void G__setup_memvarTEveCompositeFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrame));
   { TEveCompositeFrame *p; p=(TEveCompositeFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("IconBarCreator_foo"),-2,4,"fgIconBarCreator=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,4,"fgTopFrameHeight=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,4,"fgMiniBarHeight=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgAllowTopFrameCollapse=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),-1,-1,2,"fTopFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGTextButton),-1,-1,2,"fToggleBar=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGTextButton),-1,-1,2,"fTitleBar=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),-1,-1,2,"fIconBar=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGLayoutHints),-1,-1,2,"fEveWindowLH=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGFrame),-1,-1,2,"fMiniBar=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveElement),-1,-1,2,"fEveParent=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow),-1,-1,2,"fEveWindow=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowInSync=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TContextMenu),-1,-2,2,"fgCtxMenu=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,1,G__get_linked_tagnum(&G__G__Eve1LN_TString),-1,-2,2,"fgkEmptyFrameName=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TList),-1,-2,2,"fgFrameList=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCompositeFrameInMainFrame */
static void G__setup_memvarTEveCompositeFrameInMainFrame(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInMainFrame));
   { TEveCompositeFrameInMainFrame *p; p=(TEveCompositeFrameInMainFrame*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGMainFrame),-1,-1,2,"fMainFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow),-1,-1,2,"fOriginalSlot=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow),-1,-1,2,"fOriginalContainer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCompositeFrameInPack */
static void G__setup_memvarTEveCompositeFrameInPack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInPack));
   { TEveCompositeFrameInPack *p; p=(TEveCompositeFrameInPack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGPack),-1,-1,2,"fPack=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCompositeFrameInTab */
static void G__setup_memvarTEveCompositeFrameInTab(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInTab));
   { TEveCompositeFrameInTab *p; p=(TEveCompositeFrameInTab*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGTab),-1,-1,2,"fTab=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame),-1,-1,2,"fParentInTab=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveViewerListEditor */
static void G__setup_memvarTEveViewerListEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerListEditor));
   { TEveViewerListEditor *p; p=(TEveViewerListEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerList),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator),-1,-1,2,"fBrightness=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGTextButton),-1,-1,2,"fColorSet=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveWindowEditor */
static void G__setup_memvarTEveWindowEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowEditor));
   { TEveWindowEditor *p; p=(TEveWindowEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TGCheckButton),-1,-1,2,"fShowTitleBar=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveSecondarySelectable */
static void G__setup_memvarTEveSecondarySelectable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSecondarySelectable));
   { TEveSecondarySelectable *p; p=(TEveSecondarySelectable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAlwaysSecSelect=",0,"Always do secondary-selection in GL.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR),G__defined_typename("SelectionSet_t"),-1,2,"fSelectedSet=",0,"Selected indices.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR),G__defined_typename("SelectionSet_t"),-1,2,"fHighlightedSet=",0,"Highlighted indices.");
   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__Eve1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__Eve1() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTEveElement(void) {
   /* TEveElement */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElement));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 1, 1, 1, 4, 0, "u 'TEveElement' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("PreDeleteElement",1604,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveElementsInternal",2280,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AnnihilateRecursively",2202,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ToString",826,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 1, 3, 2, 1, "g - 'Bool_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveElement",1086,G__G__Eve1_131_0_6, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveElement",1086,G__G__Eve1_131_0_7, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 1, 1, 1, 0, "s - 'Color_t' 1 - main_color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveElement",1086,G__G__Eve1_131_0_8, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 1, 1, 1, 0, "u 'TEveElement' - 11 - e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloneElement",1211,G__G__Eve1_131_0_9, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloneElementRecurse",1940,G__G__Eve1_131_0_10, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' level", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloneChildrenRecurse",2035,G__G__Eve1_131_0_11, 121, -1, -1, 0, 2, 1, 1, 8, 
"U 'TEveElement' - 0 - dest i - 'Int_t' 0 '0' level", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetElementName",1387,G__G__Eve1_131_0_12, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetElementTitle",1516,G__G__Eve1_131_0_13, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHighlightTooltip",1955,G__G__Eve1_131_0_14, 117, G__get_linked_tagnum(&G__G__Eve1LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetElementName",1399,G__G__Eve1_131_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetElementTitle",1528,G__G__Eve1_131_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetElementNameTitle",1913,G__G__Eve1_131_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NameTitleChanged",1581,G__G__Eve1_131_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVizTag",885,G__G__Eve1_131_0_19, 117, G__get_linked_tagnum(&G__G__Eve1LN_TString), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVizTag",897,G__G__Eve1_131_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - tag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVizModel",1098,G__G__Eve1_131_0_21, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVizModel",1110,G__G__Eve1_131_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - model", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindVizModel",1195,G__G__Eve1_131_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ApplyVizTag",1115,G__G__Eve1_131_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TString' - 11 - tag u 'TString' - 11 '\"\"' fallback_tag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PropagateVizParamsToProjecteds",3094,G__G__Eve1_131_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PropagateVizParamsToElements",2880,G__G__Eve1_131_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 '0' el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyVizParams",1336,G__G__Eve1_131_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 10 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyVizParamsFromDB",1874,G__G__Eve1_131_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SaveVizParams",1324,G__G__Eve1_131_0_29, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out u 'TString' - 11 - tag "
"u 'TString' - 11 - var", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteVizParams",1448,G__G__Eve1_131_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out u 'TString' - 11 - var", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaster",908,G__G__Eve1_131_0_31, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCompound",1125,G__G__Eve1_131_0_32, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompound), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCompound",1137,G__G__Eve1_131_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveCompound' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddParent",883,G__G__Eve1_131_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - re", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveParent",1240,G__G__Eve1_131_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - re", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckReferenceCount",1910,G__G__Eve1_131_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEveException' - 11 '\"TEveElement::CheckReferenceCount \"' eh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CollectSceneParents",1937,G__G__Eve1_131_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'list<TEveElement*,allocator<TEveElement*> >' 'TEveElement::List_t' 1 - scenes", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CollectSceneParentsFromChildren",3150,G__G__Eve1_131_0_38, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'list<TEveElement*,allocator<TEveElement*> >' 'TEveElement::List_t' 1 - scenes U 'TEveElement' - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BeginParents",1218,G__G__Eve1_131_0_39, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), G__defined_typename("TEveElement::List_i"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EndParents",1012,G__G__Eve1_131_0_40, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), G__defined_typename("TEveElement::List_i"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginParents",1218,G__G__Eve1_131_0_41, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), G__defined_typename("TEveElement::List_ci"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EndParents",1012,G__G__Eve1_131_0_42, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), G__defined_typename("TEveElement::List_ci"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NumParents",1037,G__G__Eve1_131_0_43, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasParents",1017,G__G__Eve1_131_0_44, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefChildren",1094,G__G__Eve1_131_0_45, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR), G__defined_typename("TEveElement::List_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginChildren",1294,G__G__Eve1_131_0_46, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), G__defined_typename("TEveElement::List_i"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EndChildren",1088,G__G__Eve1_131_0_47, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), G__defined_typename("TEveElement::List_i"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BeginChildren",1294,G__G__Eve1_131_0_48, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), G__defined_typename("TEveElement::List_ci"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EndChildren",1088,G__G__Eve1_131_0_49, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), G__defined_typename("TEveElement::List_ci"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NumChildren",1113,G__G__Eve1_131_0_50, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasChildren",1093,G__G__Eve1_131_0_51, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasChild",768,G__G__Eve1_131_0_52, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindChild",869,G__G__Eve1_131_0_53, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - name U 'TClass' - 10 '0' cls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindChild",869,G__G__Eve1_131_0_54, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 2, 1, 1, 0, 
"u 'TPRegexp' - 1 - regexp U 'TClass' - 10 '0' cls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindChildren",1194,G__G__Eve1_131_0_55, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"u 'list<TEveElement*,allocator<TEveElement*> >' 'TEveElement::List_t' 1 - matches u 'TString' - 11 - name "
"U 'TClass' - 10 '0' cls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindChildren",1194,G__G__Eve1_131_0_56, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"u 'list<TEveElement*,allocator<TEveElement*> >' 'TEveElement::List_t' 1 - matches u 'TPRegexp' - 1 - regexp "
"U 'TClass' - 10 '0' cls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FirstChild",1004,G__G__Eve1_131_0_57, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LastChild",888,G__G__Eve1_131_0_58, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnableListElements",1824,G__G__Eve1_131_0_59, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' rnr_self g - 'Bool_t' 0 'kTRUE' rnr_children", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("DisableListElements",1933,G__G__Eve1_131_0_60, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kFALSE' rnr_self g - 'Bool_t' 0 'kFALSE' rnr_children", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("GetDestroyOnZeroRefCnt",2217,G__G__Eve1_131_0_61, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDestroyOnZeroRefCnt",2229,G__G__Eve1_131_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDenyDestroy",1434,G__G__Eve1_131_0_63, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncDenyDestroy",1428,G__G__Eve1_131_0_64, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DecDenyDestroy",1414,G__G__Eve1_131_0_65, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParentIgnoreCnt",1811,G__G__Eve1_131_0_66, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncParentIgnoreCnt",1805,G__G__Eve1_131_0_67, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DecParentIgnoreCnt",1791,G__G__Eve1_131_0_68, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PadPaint",785,G__G__Eve1_131_0_69, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintStandard",1325,G__G__Eve1_131_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObject",887,G__G__Eve1_131_0_71, 85, G__get_linked_tagnum(&G__G__Eve1LN_TObject), -1, 0, 1, 1, 1, 8, "u 'TEveException' - 11 - eh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEditorObject",1502,G__G__Eve1_131_0_72, 85, G__get_linked_tagnum(&G__G__Eve1LN_TObject), -1, 0, 1, 1, 1, 8, "u 'TEveException' - 11 - eh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRenderObject",1495,G__G__Eve1_131_0_73, 85, G__get_linked_tagnum(&G__G__Eve1LN_TObject), -1, 0, 1, 1, 1, 8, "u 'TEveException' - 11 - eh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExpandIntoListTree",1830,G__G__Eve1_131_0_74, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTree' - 0 - ltree U 'TGListTreeItem' - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DestroyListSubTree",1856,G__G__Eve1_131_0_75, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTree' - 0 - ltree U 'TGListTreeItem' - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddIntoListTree",1487,G__G__Eve1_131_0_76, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGListTreeItem), -1, 0, 2, 1, 1, 0, 
"U 'TGListTree' - 0 - ltree U 'TGListTreeItem' - 0 - parent_lti", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddIntoListTree",1487,G__G__Eve1_131_0_77, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGListTreeItem), -1, 0, 2, 1, 1, 0, 
"U 'TGListTree' - 0 - ltree U 'TEveElement' - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddIntoListTrees",1602,G__G__Eve1_131_0_78, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGListTreeItem), -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveFromListTree",1838,G__G__Eve1_131_0_79, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TGListTree' - 0 - ltree U 'TGListTreeItem' - 0 - parent_lti", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveFromListTrees",1953,G__G__Eve1_131_0_80, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindItem",784,G__G__Eve1_131_0_81, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgRcLcLiterator), G__defined_typename("TEveElement::sLTI_i"), 0, 1, 1, 1, 0, "U 'TGListTree' - 0 - ltree", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindItem",784,G__G__Eve1_131_0_82, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgRcLcLiterator), G__defined_typename("TEveElement::sLTI_i"), 0, 2, 1, 1, 0, 
"U 'TGListTree' - 0 - ltree U 'TGListTreeItem' - 0 - parent_lti", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindListTreeItem",1596,G__G__Eve1_131_0_83, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGListTreeItem), -1, 0, 1, 1, 1, 0, "U 'TGListTree' - 0 - ltree", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindListTreeItem",1596,G__G__Eve1_131_0_84, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGListTreeItem), -1, 0, 2, 1, 1, 0, 
"U 'TGListTree' - 0 - ltree U 'TGListTreeItem' - 0 - parent_lti", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNItems",880,G__G__Eve1_131_0_85, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SpawnEditor",1136,G__G__Eve1_131_0_86, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("ExportToCINT",1139,G__G__Eve1_131_0_87, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 0 - var_name", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("DumpSourceObject",1630,G__G__Eve1_131_0_88, 121, -1, -1, 0, 0, 1, 1, 8, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("PrintSourceObject",1749,G__G__Eve1_131_0_89, 121, -1, -1, 0, 0, 1, 1, 8, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("ExportSourceObjectToCINT",2363,G__G__Eve1_131_0_90, 121, -1, -1, 0, 1, 1, 1, 8, "C - - 0 - var_name", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("AcceptElement",1306,G__G__Eve1_131_0_91, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddElement",979,G__G__Eve1_131_0_92, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveElement",1336,G__G__Eve1_131_0_93, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveElementLocal",1827,G__G__Eve1_131_0_94, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveElements",1451,G__G__Eve1_131_0_95, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveElementsLocal",1942,G__G__Eve1_131_0_96, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AnnihilateElements",1850,G__G__Eve1_131_0_97, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Annihilate",1021,G__G__Eve1_131_0_98, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProjectChild",1211,G__G__Eve1_131_0_99, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveElement' - 0 - el g - 'Bool_t' 0 'kTRUE' same_depth", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProjectAllChildren",1817,G__G__Eve1_131_0_100, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' same_depth", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Destroy",746,G__G__Eve1_131_0_101, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("DestroyOrWarn",1347,G__G__Eve1_131_0_102, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DestroyElements",1575,G__G__Eve1_131_0_103, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("HandleElementPaste",1811,G__G__Eve1_131_0_104, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ElementChanged",1396,G__G__Eve1_131_0_105, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' update_scenes g - 'Bool_t' 0 'kFALSE' redraw", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CanEditElement",1378,G__G__Eve1_131_0_106, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SingleRnrState",1429,G__G__Eve1_131_0_107, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRnrSelf",988,G__G__Eve1_131_0_108, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRnrChildren",1403,G__G__Eve1_131_0_109, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRnrState",1107,G__G__Eve1_131_0_110, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRnrAnything",1428,G__G__Eve1_131_0_111, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRnrSelf",1000,G__G__Eve1_131_0_112, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - rnr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRnrChildren",1415,G__G__Eve1_131_0_113, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - rnr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRnrSelfChildren",1809,G__G__Eve1_131_0_114, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - rnr_self g - 'Bool_t' 0 - rnr_children", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRnrState",1119,G__G__Eve1_131_0_115, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - rnr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PropagateRnrStateToProjecteds",2988,G__G__Eve1_131_0_116, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CanEditMainColor",1564,G__G__Eve1_131_0_117, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEditMainColor",1590,G__G__Eve1_131_0_118, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMainColorPtr",1498,G__G__Eve1_131_0_119, 83, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMainColorPtr",1510,G__G__Eve1_131_0_120, 121, -1, -1, 0, 1, 1, 1, 0, "S - 'Color_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasMainColor",1184,G__G__Eve1_131_0_121, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMainColor",1188,G__G__Eve1_131_0_122, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMainColor",1200,G__G__Eve1_131_0_123, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMainColorPixel",1714,G__G__Eve1_131_0_124, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - pixel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMainColorRGB",1419,G__G__Eve1_131_0_125, 121, -1, -1, 0, 3, 1, 1, 0, 
"b - 'UChar_t' 0 - r b - 'UChar_t' 0 - g "
"b - 'UChar_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMainColorRGB",1419,G__G__Eve1_131_0_126, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - r f - 'Float_t' 0 - g "
"f - 'Float_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PropagateMainColorToProjecteds",3069,G__G__Eve1_131_0_127, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 - color s - 'Color_t' 0 - old_color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CanEditMainTransparency",2327,G__G__Eve1_131_0_128, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEditMainTransparency",2353,G__G__Eve1_131_0_129, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMainTransparency",1951,G__G__Eve1_131_0_130, 99, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMainTransparency",1963,G__G__Eve1_131_0_131, 121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMainAlpha",1175,G__G__Eve1_131_0_132, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PropagateMainTransparencyToProjecteds",3832,G__G__Eve1_131_0_133, 121, -1, -1, 0, 2, 1, 1, 0, 
"c - 'Char_t' 0 - t c - 'Char_t' 0 - old_t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CanEditMainTrans",1573,G__G__Eve1_131_0_134, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasMainTrans",1193,G__G__Eve1_131_0_135, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PtrMainTrans",1219,G__G__Eve1_131_0_136, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveTrans), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' create", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RefMainTrans",1194,G__G__Eve1_131_0_137, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveTrans), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitMainTrans",1313,G__G__Eve1_131_0_138, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' can_edit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DestroyMainTrans",1655,G__G__Eve1_131_0_139, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTransMatrix",1449,G__G__Eve1_131_0_140, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - carr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTransMatrix",1449,G__G__Eve1_131_0_141, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGeoMatrix' - 11 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSource",913,G__G__Eve1_131_0_142, 117, G__get_linked_tagnum(&G__G__Eve1LN_TRef), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSourceObject",1512,G__G__Eve1_131_0_143, 85, G__get_linked_tagnum(&G__G__Eve1LN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSourceObject",1524,G__G__Eve1_131_0_144, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - o", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUserData",1081,G__G__Eve1_131_0_145, 89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUserData",1093,G__G__Eve1_131_0_146, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - ud", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsPickable",983,G__G__Eve1_131_0_147, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPickable",1095,G__G__Eve1_131_0_148, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ForwardSelection",1659,G__G__Eve1_131_0_149, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ForwardEdit",1115,G__G__Eve1_131_0_150, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SelectElement",1322,G__G__Eve1_131_0_151, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - state", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IncImpliedSelected",1799,G__G__Eve1_131_0_152, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DecImpliedSelected",1785,G__G__Eve1_131_0_153, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnSelected",1004,G__G__Eve1_131_0_154, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HighlightElement",1634,G__G__Eve1_131_0_155, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - state", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IncImpliedHighlighted",2111,G__G__Eve1_131_0_156, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DecImpliedHighlighted",2097,G__G__Eve1_131_0_157, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnHighlighted",1316,G__G__Eve1_131_0_158, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillImpliedSelectedSet",2208,G__G__Eve1_131_0_159, 121, -1, -1, 0, 1, 1, 1, 0, "u 'set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >' 'TEveElement::Set_t' 1 - impSelSet", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSelectedLevel",1601,G__G__Eve1_131_0_160, 98, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecheckImpliedSelections",2450,G__G__Eve1_131_0_161, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCSCBits",919,G__G__Eve1_131_0_162, 121, -1, -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetCSCBits",1134,G__G__Eve1_131_0_163, 121, -1, -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TestCSCBits",1035,G__G__Eve1_131_0_164, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "b - 'UChar_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetAllCSCBits",1415,G__G__Eve1_131_0_165, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CSCImplySelectAllChildren",2438,G__G__Eve1_131_0_166, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CSCTakeAnyParentAsMaster",2320,G__G__Eve1_131_0_167, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CSCApplyMainColorToAllChildren",2920,G__G__Eve1_131_0_168, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CSCApplyMainColorToMatchingChildren",3450,G__G__Eve1_131_0_169, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CSCApplyMainTransparencyToAllChildren",3683,G__G__Eve1_131_0_170, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CSCApplyMainTransparencyToMatchingChildren",4213,G__G__Eve1_131_0_171, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StampColorSelection",1962,G__G__Eve1_131_0_172, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StampTransBBox",1400,G__G__Eve1_131_0_173, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StampObjProps",1332,G__G__Eve1_131_0_174, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StampVisibility",1581,G__G__Eve1_131_0_175, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddStamp",782,G__G__Eve1_131_0_176, 121, -1, -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 0 - bits", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearStamps",1119,G__G__Eve1_131_0_177, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetChangeBits",1272,G__G__Eve1_131_0_178, 98, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListTreeIcon",1493,G__G__Eve1_131_0_179, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGPicture), -1, 0, 1, 1, 1, 1, "g - 'Bool_t' 0 'kFALSE' open", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListTreeCheckBoxIcon",2268,G__G__Eve1_131_0_180, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGPicture), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("VizDB_Apply",1060,G__G__Eve1_131_0_181, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - tag", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("VizDB_Reapply",1275,G__G__Eve1_131_0_182, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("VizDB_UpdateModel",1650,G__G__Eve1_131_0_183, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' update", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("VizDB_Insert",1171,G__G__Eve1_131_0_184, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - tag g - 'Bool_t' 0 'kTRUE' replace "
"g - 'Bool_t' 0 'kTRUE' update", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_131_0_185, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveElement::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_131_0_186, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElement::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_131_0_187, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveElement::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_131_0_188, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveElement::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_131_0_189, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_131_0_190, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Eve1_131_0_191, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve1_131_0_192, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve1_131_0_193, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElement::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_131_0_194, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveElement::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_131_0_195, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElement::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_131_0_196, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveElement::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveElement", 1212, G__G__Eve1_131_0_197, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveUtil(void) {
   /* TEveUtil */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveUtil));
   G__memfunc_setup("SetupEnvironment",1702,G__G__Eve1_132_0_1, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveUtil::SetupEnvironment) ), 0);
   G__memfunc_setup("SetupGUI",758,G__G__Eve1_132_0_2, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveUtil::SetupGUI) ), 0);
   G__memfunc_setup("CheckMacro",976,G__G__Eve1_132_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 1, 3, 1, 0, "C - - 10 - mac", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const char*))(&TEveUtil::CheckMacro) ), 0);
   G__memfunc_setup("AssertMacro",1124,G__G__Eve1_132_0_4, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 - mac", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TEveUtil::AssertMacro) ), 0);
   G__memfunc_setup("Macro",498,G__G__Eve1_132_0_5, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 - mac", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TEveUtil::Macro) ), 0);
   G__memfunc_setup("LoadMacro",882,G__G__Eve1_132_0_6, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 - mac", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TEveUtil::LoadMacro) ), 0);
   G__memfunc_setup("ColorFromIdx",1208,G__G__Eve1_132_0_7, 121, -1, -1, 0, 3, 3, 1, 0, 
"s - 'Color_t' 0 - ci B - 'UChar_t' 0 - col "
"g - 'Bool_t' 0 'kTRUE' alpha", (char*)NULL, (void*) G__func2void( (void (*)(Color_t, UChar_t*, Bool_t))(&TEveUtil::ColorFromIdx) ), 0);
   G__memfunc_setup("ColorFromIdx",1208,G__G__Eve1_132_0_8, 121, -1, -1, 0, 3, 3, 1, 0, 
"s - 'Color_t' 0 - ci B - 'UChar_t' 0 - col "
"c - 'Char_t' 0 - transparency", (char*)NULL, (void*) G__func2void( (void (*)(Color_t, UChar_t*, Char_t))(&TEveUtil::ColorFromIdx) ), 0);
   G__memfunc_setup("ColorFromIdx",1208,G__G__Eve1_132_0_9, 121, -1, -1, 0, 6, 3, 1, 0, 
"f - 'Float_t' 0 - f1 s - 'Color_t' 0 - c1 "
"f - 'Float_t' 0 - f2 s - 'Color_t' 0 - c2 "
"B - 'UChar_t' 0 - col g - 'Bool_t' 0 'kTRUE' alpha", (char*)NULL, (void*) G__func2void( (void (*)(Float_t, Color_t, Float_t, Color_t, UChar_t*, Bool_t))(&TEveUtil::ColorFromIdx) ), 0);
   G__memfunc_setup("FindColorVar",1193,G__G__Eve1_132_0_10, 83, -1, G__defined_typename("Color_t"), 0, 2, 3, 1, 0, 
"U 'TObject' - 0 - obj C - - 10 - varname", (char*)NULL, (void*) G__func2void( (Color_t* (*)(TObject*, const char*))(&TEveUtil::FindColorVar) ), 0);
   G__memfunc_setup("SetColorBrightness",1860,G__G__Eve1_132_0_11, 121, -1, -1, 0, 2, 3, 1, 0, 
"f - 'Float_t' 0 - value g - 'Bool_t' 0 'kFALSE' full_redraw", (char*)NULL, (void*) G__func2void( (void (*)(Float_t, Bool_t))(&TEveUtil::SetColorBrightness) ), 0);
   G__memfunc_setup("IsU1IntervalContainedByMinMax",2849,G__G__Eve1_132_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 4, 3, 1, 0, 
"f - 'Float_t' 0 - minM f - 'Float_t' 0 - maxM "
"f - 'Float_t' 0 - minQ f - 'Float_t' 0 - maxQ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(Float_t, Float_t, Float_t, Float_t))(&TEveUtil::IsU1IntervalContainedByMinMax) ), 0);
   G__memfunc_setup("IsU1IntervalOverlappingByMinMax",3091,G__G__Eve1_132_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 4, 3, 1, 0, 
"f - 'Float_t' 0 - minM f - 'Float_t' 0 - maxM "
"f - 'Float_t' 0 - minQ f - 'Float_t' 0 - maxQ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(Float_t, Float_t, Float_t, Float_t))(&TEveUtil::IsU1IntervalOverlappingByMinMax) ), 0);
   G__memfunc_setup("IsU1IntervalContainedByMeanDelta",3138,G__G__Eve1_132_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 4, 3, 1, 0, 
"f - 'Float_t' 0 - meanM f - 'Float_t' 0 - deltaM "
"f - 'Float_t' 0 - meanQ f - 'Float_t' 0 - deltaQ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(Float_t, Float_t, Float_t, Float_t))(&TEveUtil::IsU1IntervalContainedByMeanDelta) ), 0);
   G__memfunc_setup("IsU1IntervalOverlappingByMeanDelta",3380,G__G__Eve1_132_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 4, 3, 1, 0, 
"f - 'Float_t' 0 - meanM f - 'Float_t' 0 - deltaM "
"f - 'Float_t' 0 - meanQ f - 'Float_t' 0 - deltaQ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(Float_t, Float_t, Float_t, Float_t))(&TEveUtil::IsU1IntervalOverlappingByMeanDelta) ), 0);
   G__memfunc_setup("GetFraction",1110,G__G__Eve1_132_0_16, 102, -1, G__defined_typename("Float_t"), 0, 4, 3, 1, 0, 
"f - 'Float_t' 0 - minM f - 'Float_t' 0 - maxM "
"f - 'Float_t' 0 - minQ f - 'Float_t' 0 - maxQ", (char*)NULL, (void*) G__func2void( (Float_t (*)(Float_t, Float_t, Float_t, Float_t))(&TEveUtil::GetFraction) ), 0);
   G__memfunc_setup("Class",502,G__G__Eve1_132_0_17, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveUtil::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_132_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveUtil::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_132_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveUtil::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_132_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveUtil::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_132_0_21, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_132_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Eve1_132_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve1_132_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__Eve1_132_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveUtil::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_132_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveUtil::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_132_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveUtil::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_132_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveUtil::DeclFileLine) ), 0);
   // automatic default constructor
   G__memfunc_setup("TEveUtil", 786, G__G__Eve1_132_0_29, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveUtil), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TEveUtil", 786, G__G__Eve1_132_0_30, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveUtil), -1, 0, 1, 1, 1, 0, "u 'TEveUtil' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveUtil", 912, G__G__Eve1_132_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_132_0_32, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveUtil), -1, 1, 1, 1, 1, 0, "u 'TEveUtil' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveException(void) {
   /* TEveException */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveException));
   G__memfunc_setup("TEveException",1315,G__G__Eve1_133_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveException), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveException",1315,G__G__Eve1_133_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveException), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveException",1315,G__G__Eve1_133_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveException), -1, 0, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveException",1315,G__G__Eve1_133_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveException), -1, 0, 1, 1, 1, 0, "u 'string' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("what",436,G__G__Eve1_133_0_5, 67, -1, -1, 0, 0, 1, 1, 41, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_133_0_6, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveException::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_133_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveException::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_133_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveException::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_133_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveException::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_133_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__Eve1_133_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveException::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_133_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveException::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_133_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveException::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_133_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveException::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEveException", 1315, G__G__Eve1_133_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveException), -1, 0, 1, 1, 1, 0, "u 'TEveException' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveException", 1441, G__G__Eve1_133_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_133_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveException), -1, 1, 1, 1, 1, 0, "u 'TEveException' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvePadHolder(void) {
   /* TEvePadHolder */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePadHolder));
   G__memfunc_setup("TEvePadHolder",1255,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEvePadHolder), -1, 0, 1, 1, 4, 0, "u 'TEvePadHolder' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEvePadHolder), -1, 1, 1, 1, 4, 0, "u 'TEvePadHolder' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEvePadHolder",1255,G__G__Eve1_134_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEvePadHolder), -1, 0, 3, 1, 1, 0, 
"g - 'Bool_t' 0 - modify_update_p U 'TVirtualPad' - 0 '0' new_pad "
"i - 'Int_t' 0 '0' subpad", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_134_0_4, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvePadHolder::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_134_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePadHolder::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_134_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvePadHolder::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_134_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvePadHolder::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_134_0_8, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_134_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__Eve1_134_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__Eve1_134_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__Eve1_134_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePadHolder::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_134_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePadHolder::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_134_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePadHolder::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_134_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePadHolder::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEvePadHolder", 1381, G__G__Eve1_134_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGeoManagerHolder(void) {
   /* TEveGeoManagerHolder */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGeoManagerHolder));
   G__memfunc_setup("TEveGeoManagerHolder",1960,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveGeoManagerHolder), -1, 0, 1, 1, 4, 0, "u 'TEveGeoManagerHolder' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveGeoManagerHolder), -1, 1, 1, 1, 4, 0, "u 'TEveGeoManagerHolder' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveGeoManagerHolder",1960,G__G__Eve1_135_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveGeoManagerHolder), -1, 0, 2, 1, 1, 0, 
"U 'TGeoManager' - 0 '0' new_gmgr i - 'Int_t' 0 '0' n_seg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_135_0_4, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGeoManagerHolder::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_135_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoManagerHolder::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_135_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGeoManagerHolder::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_135_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGeoManagerHolder::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_135_0_8, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_135_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__Eve1_135_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__Eve1_135_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__Eve1_135_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoManagerHolder::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_135_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoManagerHolder::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_135_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoManagerHolder::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_135_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoManagerHolder::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGeoManagerHolder", 2086, G__G__Eve1_135_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveRefCnt(void) {
   /* TEveRefCnt */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRefCnt));
   G__memfunc_setup("TEveRefCnt",950,G__G__Eve1_136_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveRefCnt), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveRefCnt",950,G__G__Eve1_136_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveRefCnt), -1, 0, 1, 1, 1, 0, "u 'TEveRefCnt' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Eve1_136_0_3, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveRefCnt), -1, 1, 1, 1, 1, 0, "u 'TEveRefCnt' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncRefCount",1088,G__G__Eve1_136_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DecRefCount",1074,G__G__Eve1_136_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OnZeroRefCount",1411,G__G__Eve1_136_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_136_0_7, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveRefCnt::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_136_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRefCnt::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_136_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveRefCnt::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_136_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveRefCnt::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_136_0_11, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_136_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__Eve1_136_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__Eve1_136_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__Eve1_136_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRefCnt::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_136_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRefCnt::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_136_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRefCnt::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_136_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRefCnt::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveRefCnt", 1076, G__G__Eve1_136_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveRefBackPtr(void) {
   /* TEveRefBackPtr */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRefBackPtr));
   G__memfunc_setup("TEveRefBackPtr",1336,G__G__Eve1_137_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveRefBackPtr), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveRefBackPtr",1336,G__G__Eve1_137_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveRefBackPtr), -1, 0, 1, 1, 1, 0, "u 'TEveRefBackPtr' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Eve1_137_0_3, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveRefBackPtr), -1, 1, 1, 1, 1, 0, "u 'TEveRefBackPtr' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncRefCount",1088,G__G__Eve1_137_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - re", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DecRefCount",1074,G__G__Eve1_137_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - re", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StampBackPtrElements",2025,G__G__Eve1_137_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 0 - stamps", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_137_0_7, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveRefBackPtr::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_137_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRefBackPtr::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_137_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveRefBackPtr::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_137_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveRefBackPtr::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_137_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__Eve1_137_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRefBackPtr::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_137_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRefBackPtr::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_137_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRefBackPtr::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_137_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRefBackPtr::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveRefBackPtr", 1462, G__G__Eve1_137_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveProjection(void) {
   /* TEveProjection */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjection));
   G__memfunc_setup("PreScaleVariable",1589,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - dim f - 'Float_t' 1 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Is2D",306,G__G__Eve1_147_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Is3D",307,G__G__Eve1_147_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ProjectPoint",1249,G__G__Eve1_147_0_5, 121, -1, -1, 0, 5, 1, 1, 0, 
"f - 'Float_t' 1 - x f - 'Float_t' 1 - y "
"f - 'Float_t' 1 - z f - 'Float_t' 0 - d "
"i 'TEveProjection::EPProc_e' - 0 'kPP_Full' p", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ProjectPointfv",1469,G__G__Eve1_147_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 0 - v f - 'Float_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProjectPointdv",1467,G__G__Eve1_147_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - v f - 'Float_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProjectVector",1354,G__G__Eve1_147_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TEveVectorT<float>' 'TEveVector' 1 - v f - 'Float_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProjectPointfv",1469,G__G__Eve1_147_0_9, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TEveTrans' - 10 - t F - 'Float_t' 10 - p "
"F - 'Float_t' 0 - v f - 'Float_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProjectPointdv",1467,G__G__Eve1_147_0_10, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TEveTrans' - 10 - t D - 'Double_t' 10 - p "
"D - 'Double_t' 0 - v f - 'Float_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProjectVector",1354,G__G__Eve1_147_0_11, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TEveTrans' - 10 - t u 'TEveVectorT<float>' 'TEveVector' 1 - v "
"f - 'Float_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,G__G__Eve1_147_0_12, 67, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetName",685,G__G__Eve1_147_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Char_t' 10 - txt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCenter",909,G__G__Eve1_147_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEveVectorT<float>' 'TEveVector' 1 - v", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetProjectedCenter",1825,G__G__Eve1_147_0_15, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetType",718,G__G__Eve1_147_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TEveProjection::EPType_e' - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__G__Eve1_147_0_17, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLEPType_e), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGeoMode",972,G__G__Eve1_147_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TEveProjection::EGeoMode_e' - 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGeoMode",960,G__G__Eve1_147_0_19, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLEGeoMode_e), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateLimit",1122,G__G__Eve1_147_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUsePreScale",1372,G__G__Eve1_147_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUsePreScale",1384,G__G__Eve1_147_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PreScalePoint",1305,G__G__Eve1_147_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 1 - x f - 'Float_t' 1 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PreScalePoint",1305,G__G__Eve1_147_0_24, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 1 - x f - 'Float_t' 1 - y "
"f - 'Float_t' 1 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPreScaleEntry",1578,G__G__Eve1_147_0_25, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - coord f - 'Float_t' 0 - max_val "
"f - 'Float_t' 0 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ChangePreScaleEntry",1895,G__G__Eve1_147_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - coord i - 'Int_t' 0 - entry "
"f - 'Float_t' 0 - new_scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearPreScales",1385,G__G__Eve1_147_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDistortion",1371,G__G__Eve1_147_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDistortion",1359,G__G__Eve1_147_0_29, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFixR",665,G__G__Eve1_147_0_30, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFixZ",673,G__G__Eve1_147_0_31, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFixR",677,G__G__Eve1_147_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFixZ",685,G__G__Eve1_147_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPastFixRFac",1339,G__G__Eve1_147_0_34, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPastFixZFac",1347,G__G__Eve1_147_0_35, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPastFixRFac",1351,G__G__Eve1_147_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPastFixZFac",1359,G__G__Eve1_147_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxTrackStep",1495,G__G__Eve1_147_0_38, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxTrackStep",1507,G__G__Eve1_147_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasSeveralSubSpaces",1911,G__G__Eve1_147_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AcceptSegment",1315,G__G__Eve1_147_0_41, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 8, 
"u 'TEveVectorT<float>' 'TEveVector' 1 - - u 'TEveVectorT<float>' 'TEveVector' 1 - - "
"f - 'Float_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SubSpaceId",963,G__G__Eve1_147_0_42, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "u 'TEveVectorT<float>' 'TEveVector' 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsOnSubSpaceBoundrary",2117,G__G__Eve1_147_0_43, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TEveVectorT<float>' 'TEveVector' 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BisectBreakPoint",1609,G__G__Eve1_147_0_44, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TEveVectorT<float>' 'TEveVector' 1 - vL u 'TEveVectorT<float>' 'TEveVector' 1 - vR "
"f - 'Float_t' 0 '1e-10f' eps_sqr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDirectionalVector",2061,G__G__Eve1_147_0_45, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - screenAxis u 'TEveVectorT<float>' 'TEveVector' 1 - vec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValForScreenPos",1788,G__G__Eve1_147_0_46, 102, -1, G__defined_typename("Float_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - ax f - 'Float_t' 0 - value", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetScreenVal",1187,G__G__Eve1_147_0_47, 102, -1, G__defined_typename("Float_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - ax f - 'Float_t' 0 - value", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLimit",799,G__G__Eve1_147_0_48, 102, -1, G__defined_typename("Float_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - i g - 'Bool_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_147_0_49, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveProjection::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_147_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjection::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_147_0_51, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveProjection::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_147_0_52, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveProjection::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_147_0_53, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_147_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Eve1_147_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve1_147_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve1_147_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjection::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_147_0_58, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjection::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_147_0_59, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjection::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_147_0_60, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjection::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveProjection", 1551, G__G__Eve1_147_0_61, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_147_0_62, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveProjection), -1, 1, 1, 1, 1, 0, "u 'TEveProjection' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveProjected(void) {
   /* TEveProjected */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjected));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjected), -1, 1, 1, 1, 4, 0, "u 'TEveProjected' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("SetDepthCommon",1418,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"f - 'Float_t' 0 - d U 'TEveElement' - 0 - el "
"F - 'Float_t' 0 - bbox", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDepthLocal",1292,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "f - 'Float_t' 0 - d", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetManager",987,G__G__Eve1_148_0_6, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProjectable",1419,G__G__Eve1_148_0_7, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDepth",789,G__G__Eve1_148_0_8, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProjection",1353,G__G__Eve1_148_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveProjectionManager' - 0 - mng U 'TEveProjectable' - 0 - model", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnRefProjectable",1611,G__G__Eve1_148_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveProjectable' - 0 - assumed_parent g - - 0 'true' notifyParent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateProjection",1664,G__G__Eve1_148_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetProjectedAsElement",2110,G__G__Eve1_148_0_12, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDepth",801,G__G__Eve1_148_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - d", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_148_0_14, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveProjected::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_148_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjected::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_148_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveProjected::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_148_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveProjected::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_148_0_18, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_148_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__Eve1_148_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__Eve1_148_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__Eve1_148_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjected::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_148_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjected::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_148_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjected::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_148_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjected::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveProjected", 1426, G__G__Eve1_148_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveProjectionManager(void) {
   /* TEveProjectionManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager));
   G__memfunc_setup("TEveProjectionManager",2124,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager), -1, 0, 1, 1, 4, 0, "u 'TEveProjectionManager' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager), -1, 1, 1, 1, 4, 0, "u 'TEveProjectionManager' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("ShouldImport",1258,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateDependentElsAndScenes",2706,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TEveElement' - 0 - root", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TEveProjectionManager",2124,G__G__Eve1_149_0_5, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager), -1, 0, 1, 1, 1, 0, "i 'TEveProjection::EPType_e' - 0 'TEveProjection::kPT_Unknown' type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddDependent",1184,G__G__Eve1_149_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveDependent",1541,G__G__Eve1_149_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProjection",1353,G__G__Eve1_149_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TEveProjection::EPType_e' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProjection",1341,G__G__Eve1_149_0_9, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjection), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateName",996,G__G__Eve1_149_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCenter",909,G__G__Eve1_149_0_11, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
"f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCenter",897,G__G__Eve1_149_0_12, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), G__defined_typename("TEveVector"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentDepth",1540,G__G__Eve1_149_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentDepth",1528,G__G__Eve1_149_0_14, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetImportEmpty",1462,G__G__Eve1_149_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - ie", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetImportEmpty",1450,G__G__Eve1_149_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleElementPaste",1811,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ImportElementsRecurse",2193,G__G__Eve1_149_0_18, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 2, 1, 1, 0, 
"U 'TEveElement' - 0 - el U 'TEveElement' - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ImportElements",1464,G__G__Eve1_149_0_19, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 2, 1, 1, 0, 
"U 'TEveElement' - 0 - el U 'TEveElement' - 0 '0' ext_list", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SubImportElements",1762,G__G__Eve1_149_0_20, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 2, 1, 1, 0, 
"U 'TEveElement' - 0 - el U 'TEveElement' - 0 - proj_parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SubImportChildren",1742,G__G__Eve1_149_0_21, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TEveElement' - 0 - el U 'TEveElement' - 0 - proj_parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProjectChildren",1536,G__G__Eve1_149_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProjectChildrenRecurse",2265,G__G__Eve1_149_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_149_0_25, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveProjectionManager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_149_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectionManager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_149_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveProjectionManager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_149_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveProjectionManager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_149_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__Eve1_149_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectionManager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_149_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjectionManager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_149_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectionManager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_149_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjectionManager::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveProjectionManager", 2250, G__G__Eve1_149_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveProjectable(void) {
   /* TEveProjectable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectable), -1, 1, 1, 1, 4, 0, "u 'TEveProjectable' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("ProjectedClass",1430,G__G__Eve1_150_0_4, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 1, 1, 1, 8, "U 'TEveProjection' - 10 - p", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("HasProjecteds",1327,G__G__Eve1_150_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BeginProjecteds",1528,G__G__Eve1_150_0_6, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveProjectedmUcOallocatorlETEveProjectedmUgRsPgRcLcLiterator), G__defined_typename("TEveProjectable::ProjList_i"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EndProjecteds",1322,G__G__Eve1_150_0_7, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveProjectedmUcOallocatorlETEveProjectedmUgRsPgRcLcLiterator), G__defined_typename("TEveProjectable::ProjList_i"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddProjected",1193,G__G__Eve1_150_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveProjected' - 0 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveProjected",1550,G__G__Eve1_150_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveProjected' - 0 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AnnihilateProjecteds",2064,G__G__Eve1_150_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearProjectedList",1827,G__G__Eve1_150_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddProjectedsToSet",1803,G__G__Eve1_150_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >' 'set<TEveElement*>' 1 - set", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PropagateVizParams",1856,G__G__Eve1_150_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 '0' el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PropagateRenderState",2052,G__G__Eve1_150_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - rnr_self g - 'Bool_t' 0 - rnr_children", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PropagateMainColor",1831,G__G__Eve1_150_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 - color s - 'Color_t' 0 - old_color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PropagateMainTransparency",2594,G__G__Eve1_150_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"c - 'Char_t' 0 - t c - 'Char_t' 0 - old_t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_150_0_17, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveProjectable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_150_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_150_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveProjectable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_150_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveProjectable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_150_0_21, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_150_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Eve1_150_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve1_150_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__Eve1_150_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_150_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjectable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_150_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_150_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjectable::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveProjectable", 1629, G__G__Eve1_150_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR(void) {
   /* set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR));
   G__memfunc_setup("set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >",5602,G__G__Eve1_156_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >",5602,G__G__Eve1_156_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR), -1, 0, 1, 1, 1, 0, "u 'set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Eve1_156_0_3, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR), -1, 1, 1, 1, 1, 0, "u 'set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__G__Eve1_156_0_4, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__G__Eve1_156_0_5, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__G__Eve1_156_0_6, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__G__Eve1_156_0_7, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__G__Eve1_156_0_8, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__G__Eve1_156_0_9, 104, -1, G__defined_typename("set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__G__Eve1_156_0_10, 104, -1, G__defined_typename("set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Eve1_156_0_11, 117, G__get_linked_tagnum(&G__G__Eve1LN_pairlEsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiteratorcOboolgR), -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 41 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Eve1_156_0_12, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator' - 0 - position U 'TEveElement' - 41 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__G__Eve1_156_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__G__Eve1_156_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator' - 0 - first u 'set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__G__Eve1_156_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__G__Eve1_156_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("find",417,G__G__Eve1_156_0_17, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 8, "U 'TEveElement' - 41 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("count",553,G__G__Eve1_156_0_18, 104, -1, G__defined_typename("set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::size_type"), 0, 1, 1, 1, 8, "U 'TEveElement' - 41 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("lower_bound",1184,G__G__Eve1_156_0_19, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 8, "U 'TEveElement' - 41 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("upper_bound",1187,G__G__Eve1_156_0_20, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 8, "U 'TEveElement' - 41 - x", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >", 5728, G__G__Eve1_156_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator(void) {
   /* set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator));
   G__memfunc_setup("iterator",874,G__G__Eve1_157_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Eve1_157_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "u 'set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Eve1_157_0_3, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 1, 1, 1, 1, 0, "u 'set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Eve1_157_0_4, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), G__defined_typename("set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::value_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator->",983,G__G__Eve1_157_0_5, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), G__defined_typename("set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::value_type"), 2, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Eve1_157_0_6, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Eve1_157_0_7, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "i - - 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Eve1_157_0_8, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Eve1_157_0_9, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "i - - 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Eve1_157_0_10, 103, -1, -1, 0, 1, 1, 1, 0, "u 'set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__G__Eve1_157_0_11, 103, -1, -1, 0, 1, 1, 1, 0, "u 'set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator' - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~iterator", 1000, G__G__Eve1_157_0_12, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCompound(void) {
   /* TEveCompound */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompound));
   G__memfunc_setup("TEveCompound",1209,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompound), -1, 0, 1, 1, 4, 0, "u 'TEveCompound' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompound), -1, 1, 1, 1, 4, 0, "u 'TEveCompound' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveCompound",1209,G__G__Eve1_167_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompound), -1, 0, 4, 1, 1, 0, 
"C - - 10 '\"TEveCompound\"' n C - - 10 '\"\"' t "
"g - 'Bool_t' 0 'kTRUE' doColor g - 'Bool_t' 0 'kFALSE' doTransparency", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OpenCompound",1239,G__G__Eve1_167_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseCompound",1339,G__G__Eve1_167_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCompoundOpen",1427,G__G__Eve1_167_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMainColor",1200,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMainTransparency",1963,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddElement",979,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveElementLocal",1827,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveElementsLocal",1942,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillImpliedSelectedSet",2208,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >' 'TEveElement::Set_t' 1 - impSelSet", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProjectedClass",1430,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 1, 1, 1, 8, "U 'TEveProjection' - 10 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_167_0_14, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCompound::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_167_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompound::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_167_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCompound::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_167_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCompound::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_167_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__Eve1_167_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompound::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_167_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCompound::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_167_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompound::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_167_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCompound::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCompound", 1335, G__G__Eve1_167_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTrans(void) {
   /* TEveTrans */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTrans));
   G__memfunc_setup("Norm3Column",1085,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 2, 0, "i - 'Int_t' 0 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Orto3Column",1093,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - col i - 'Int_t' 0 - ref", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveTrans",892,G__G__Eve1_168_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveTrans), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveTrans",892,G__G__Eve1_168_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveTrans), -1, 0, 1, 1, 1, 0, "u 'TEveTrans' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveTrans",892,G__G__Eve1_168_0_5, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveTrans), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - arr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveTrans",892,G__G__Eve1_168_0_6, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveTrans), -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - arr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnitTrans",936,G__G__Eve1_168_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ZeroTrans",936,G__G__Eve1_168_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '1.0' w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnitRot",725,G__G__Eve1_168_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrans",820,G__G__Eve1_168_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TEveTrans' - 11 - t g - 'Bool_t' 0 'kTRUE' copyAngles", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFromArray",1215,G__G__Eve1_168_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - arr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFromArray",1215,G__G__Eve1_168_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - arr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Eve1_168_0_13, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveTrans), -1, 1, 1, 1, 1, 0, "u 'TEveTrans' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetupRotation",1377,G__G__Eve1_168_0_14, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j "
"d - 'Double_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetupFromToVec",1414,G__G__Eve1_168_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TEveVectorT<float>' 'TEveVector' 11 - from u 'TEveVectorT<float>' 'TEveVector' 11 - to", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OrtoNorm3",883,G__G__Eve1_168_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Invert",632,G__G__Eve1_168_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultLeft",813,G__G__Eve1_168_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEveTrans' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultRight",928,G__G__Eve1_168_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEveTrans' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Eve1_168_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEveTrans' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TransposeRotationPart",2214,G__G__Eve1_168_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Eve1_168_0_22, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveTrans), -1, 0, 1, 1, 1, 0, "u 'TEveTrans' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MoveLF",553,G__G__Eve1_168_0_23, 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__Eve1_168_0_24, 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("RotateLF",769,G__G__Eve1_168_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("MovePF",557,G__G__Eve1_168_0_26, 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("Move3PF",608,G__G__Eve1_168_0_27, 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("RotatePF",773,G__G__Eve1_168_0_28, 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("Move",407,G__G__Eve1_168_0_29, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TEveTrans' - 11 - a i - 'Int_t' 0 - ai "
"d - 'Double_t' 0 - amount", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Move3",458,G__G__Eve1_168_0_30, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'TEveTrans' - 11 - a d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rotate",623,G__G__Eve1_168_0_31, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'TEveTrans' - 11 - a i - 'Int_t' 0 - i1 "
"i - 'Int_t' 0 - i2 d - 'Double_t' 0 - amount", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Array",511,G__G__Eve1_168_0_32, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Array",511,G__G__Eve1_168_0_33, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ArrX",381,G__G__Eve1_168_0_34, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ArrX",381,G__G__Eve1_168_0_35, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ArrY",382,G__G__Eve1_168_0_36, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ArrY",382,G__G__Eve1_168_0_37, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ArrZ",383,G__G__Eve1_168_0_38, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ArrZ",383,G__G__Eve1_168_0_39, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ArrT",377,G__G__Eve1_168_0_40, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ArrT",377,G__G__Eve1_168_0_41, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Eve1_168_0_42, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Eve1_168_0_43, 100, -1, G__defined_typename("Double_t"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CM",144,G__G__Eve1_168_0_44, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CM",144,G__G__Eve1_168_0_45, 100, -1, G__defined_typename("Double_t"), 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Eve1_168_0_46, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Eve1_168_0_47, 100, -1, G__defined_typename("Double_t"), 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBaseVec",965,G__G__Eve1_168_0_48, 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__Eve1_168_0_49, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - b u 'TVector3' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBaseVec",953,G__G__Eve1_168_0_50, 117, G__get_linked_tagnum(&G__G__Eve1LN_TVector3), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBaseVec",953,G__G__Eve1_168_0_51, 121, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - b u 'TVector3' - 1 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPos",606,G__G__Eve1_168_0_52, 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("SetPos",606,G__G__Eve1_168_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPos",606,G__G__Eve1_168_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPos",606,G__G__Eve1_168_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEveTrans' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPos",594,G__G__Eve1_168_0_56, 121, -1, -1, 0, 3, 1, 1, 8, 
"d - 'Double_t' 1 - x d - 'Double_t' 1 - y "
"d - 'Double_t' 1 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPos",594,G__G__Eve1_168_0_57, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPos",594,G__G__Eve1_168_0_58, 121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPos",594,G__G__Eve1_168_0_59, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TVector3' - 1 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPos",594,G__G__Eve1_168_0_60, 117, G__get_linked_tagnum(&G__G__Eve1LN_TVector3), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRotByAngles",1398,G__G__Eve1_168_0_61, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - a1 f - 'Float_t' 0 - a2 "
"f - 'Float_t' 0 - a3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRotByAnyAngles",1694,G__G__Eve1_168_0_62, 121, -1, -1, 0, 4, 1, 1, 0, 
"f - 'Float_t' 0 - a1 f - 'Float_t' 0 - a2 "
"f - 'Float_t' 0 - a3 C - - 10 - pat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRotAngles",1199,G__G__Eve1_168_0_63, 121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Scale",488,G__G__Eve1_168_0_64, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - sx d - 'Double_t' 0 - sy "
"d - 'Double_t' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Unscale",715,G__G__Eve1_168_0_65, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Unscale",715,G__G__Eve1_168_0_66, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 1 - sx d - 'Double_t' 1 - sy "
"d - 'Double_t' 1 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScale",776,G__G__Eve1_168_0_67, 121, -1, -1, 0, 3, 1, 1, 8, 
"d - 'Double_t' 1 - sx d - 'Double_t' 1 - sy "
"d - 'Double_t' 1 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScale",788,G__G__Eve1_168_0_68, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - sx d - 'Double_t' 0 - sy "
"d - 'Double_t' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScaleX",876,G__G__Eve1_168_0_69, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - sx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScaleY",877,G__G__Eve1_168_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - sy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScaleZ",878,G__G__Eve1_168_0_71, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultiplyIP",1017,G__G__Eve1_168_0_72, 121, -1, -1, 0, 2, 1, 1, 8, 
"u 'TVector3' - 1 - v d - 'Double_t' 0 '1' w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultiplyIP",1017,G__G__Eve1_168_0_73, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - v d - 'Double_t' 0 '1' w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultiplyIP",1017,G__G__Eve1_168_0_74, 121, -1, -1, 0, 2, 1, 1, 8, 
"F - 'Float_t' 0 - v d - 'Double_t' 0 '1' w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Multiply",864,G__G__Eve1_168_0_75, 117, G__get_linked_tagnum(&G__G__Eve1LN_TVector3), -1, 0, 2, 1, 1, 8, 
"u 'TVector3' - 11 - v d - 'Double_t' 0 '1' w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Multiply",864,G__G__Eve1_168_0_76, 121, -1, -1, 0, 3, 1, 1, 8, 
"D - 'Double_t' 10 - vin D - 'Double_t' 0 - vout "
"d - 'Double_t' 0 '1' w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RotateIP",776,G__G__Eve1_168_0_77, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TVector3' - 1 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RotateIP",776,G__G__Eve1_168_0_78, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RotateIP",776,G__G__Eve1_168_0_79, 121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rotate",623,G__G__Eve1_168_0_80, 117, G__get_linked_tagnum(&G__G__Eve1LN_TVector3), -1, 0, 1, 1, 1, 8, "u 'TVector3' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFrom",704,G__G__Eve1_168_0_82, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - carr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrom",704,G__G__Eve1_168_0_83, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGeoMatrix' - 11 - mat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGeoHMatrix",1284,G__G__Eve1_168_0_84, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGeoHMatrix' - 1 - mat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBuffer3D",1021,G__G__Eve1_168_0_85, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer3D' - 1 - buff", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUseTrans",1109,G__G__Eve1_168_0_86, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUseTrans",1121,G__G__Eve1_168_0_87, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEditRotation",1538,G__G__Eve1_168_0_88, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEditScale",1178,G__G__Eve1_168_0_89, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEditRotation",1526,G__G__Eve1_168_0_90, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEditScale",1166,G__G__Eve1_168_0_91, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEditTrans",1198,G__G__Eve1_168_0_92, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEditTrans",1210,G__G__Eve1_168_0_93, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsScale",676,G__G__Eve1_168_0_94, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 '0.9' low d - 'Double_t' 0 '1.1' high", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_168_0_95, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTrans::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_168_0_96, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrans::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_168_0_97, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTrans::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_168_0_98, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTrans::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_168_0_102, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve1_168_0_103, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrans::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_168_0_104, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrans::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_168_0_105, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrans::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_168_0_106, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrans::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTrans", 1018, G__G__Eve1_168_0_107, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveManager(void) {
   /* TEveManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveManager));
   G__memfunc_setup("TEveManager",1071,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveManager), -1, 0, 1, 1, 4, 0, "u 'TEveManager' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveManager), -1, 1, 1, 1, 4, 0, "u 'TEveManager' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveManager",1071,G__G__Eve1_170_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveManager), -1, 0, 4, 1, 1, 0, 
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h "
"g - 'Bool_t' 0 'kTRUE' map_window C - 'Option_t' 10 '\"FI\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExcHandler",1278,G__G__Eve1_170_0_4, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveManagercLcLTExceptionHandler), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelection",1222,G__G__Eve1_170_0_5, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHighlight",1208,G__G__Eve1_170_0_6, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOrphanage",1205,G__G__Eve1_170_0_7, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUseOrphanage",1506,G__G__Eve1_170_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUseOrphanage",1518,G__G__Eve1_170_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - o", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearOrphanage",1404,G__G__Eve1_170_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBrowser",1028,G__G__Eve1_170_0_11, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLTEFrame",1008,G__G__Eve1_170_0_12, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveGListTreeEditorFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEditor",903,G__G__Eve1_170_0_13, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatusBar",1209,G__G__Eve1_170_0_14, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGStatusBar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWindowManager",1619,G__G__Eve1_170_0_15, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowManager), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScenes",897,G__G__Eve1_170_0_16, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetViewers",1029,G__G__Eve1_170_0_17, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGlobalScene",1375,G__G__Eve1_170_0_18, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveScene), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEventScene",1296,G__G__Eve1_170_0_19, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveScene), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentEvent",1541,G__G__Eve1_170_0_20, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveEventManager), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentEvent",1553,G__G__Eve1_170_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveEventManager' - 0 - mgr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddCanvasTab",1148,G__G__Eve1_170_0_22, 85, G__get_linked_tagnum(&G__G__Eve1LN_TCanvas), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMainWindow",1309,G__G__Eve1_170_0_23, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGWindow), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultViewer",1623,G__G__Eve1_170_0_24, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultGLViewer",1770,G__G__Eve1_170_0_25, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGLViewer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SpawnNewViewer",1445,G__G__Eve1_170_0_26, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 '\"\"' title "
"g - 'Bool_t' 0 'kTRUE' embed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SpawnNewScene",1313,G__G__Eve1_170_0_27, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveScene), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 '\"\"' title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMacroFolder",1390,G__G__Eve1_170_0_28, 85, G__get_linked_tagnum(&G__G__Eve1LN_TFolder), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMacro",786,G__G__Eve1_170_0_29, 85, G__get_linked_tagnum(&G__G__Eve1LN_TMacro), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EditElement",1104,G__G__Eve1_170_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - element", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisableRedraw",1305,G__G__Eve1_170_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnableRedraw",1196,G__G__Eve1_170_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Redraw3D",732,G__G__Eve1_170_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kFALSE' resetCameras g - 'Bool_t' 0 'kFALSE' dropLogicals", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterRedraw3D",1569,G__G__Eve1_170_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRedraw3D",911,G__G__Eve1_170_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FullRedraw3D",1135,G__G__Eve1_170_0_36, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kFALSE' resetCameras g - 'Bool_t' 0 'kFALSE' dropLogicals", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetKeepEmptyCont",1608,G__G__Eve1_170_0_37, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetKeepEmptyCont",1620,G__G__Eve1_170_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ElementChanged",1396,G__G__Eve1_170_0_39, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TEveElement' - 0 - element g - 'Bool_t' 0 'kTRUE' update_scenes "
"g - 'Bool_t' 0 'kFALSE' redraw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ScenesChanged",1291,G__G__Eve1_170_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'list<TEveElement*,allocator<TEveElement*> >' 'TEveElement::List_t' 1 - scenes", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ElementStamped",1432,G__G__Eve1_170_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - element", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListTree",1100,G__G__Eve1_170_0_42, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGListTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddToListTree",1272,G__G__Eve1_170_0_43, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGListTreeItem), -1, 0, 3, 1, 1, 0, 
"U 'TEveElement' - 0 - re g - 'Bool_t' 0 - open "
"U 'TGListTree' - 0 '0' lt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveFromListTree",1838,G__G__Eve1_170_0_44, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TEveElement' - 0 - element U 'TGListTree' - 0 - lt "
"U 'TGListTreeItem' - 0 - lti", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddEvent",779,G__G__Eve1_170_0_45, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGListTreeItem), -1, 0, 1, 1, 1, 0, "U 'TEveEventManager' - 0 - event", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddElement",979,G__G__Eve1_170_0_46, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveElement' - 0 - element U 'TEveElement' - 0 '0' parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddGlobalElement",1572,G__G__Eve1_170_0_47, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveElement' - 0 - element U 'TEveElement' - 0 '0' parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveElement",1336,G__G__Eve1_170_0_48, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveElement' - 0 - element U 'TEveElement' - 0 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PreDeleteElement",1604,G__G__Eve1_170_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - element", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ElementSelect",1322,G__G__Eve1_170_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - element", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ElementPaste",1223,G__G__Eve1_170_0_51, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - element", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InsertVizDBEntry",1606,G__G__Eve1_170_0_52, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"u 'TString' - 11 - tag U 'TEveElement' - 0 - model "
"g - 'Bool_t' 0 - replace g - 'Bool_t' 0 - update", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InsertVizDBEntry",1606,G__G__Eve1_170_0_53, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TString' - 11 - tag U 'TEveElement' - 0 - model", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindVizDBEntry",1362,G__G__Eve1_170_0_54, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - tag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadVizDB",831,G__G__Eve1_170_0_55, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TString' - 11 - filename g - 'Bool_t' 0 - replace "
"g - 'Bool_t' 0 - update", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadVizDB",831,G__G__Eve1_170_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveVizDB",846,G__G__Eve1_170_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVizDBReplace",1435,G__G__Eve1_170_0_58, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVizDBUpdate",1346,G__G__Eve1_170_0_59, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVizDBReplace",1447,G__G__Eve1_170_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVizDBUpdate",1358,G__G__Eve1_170_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - u", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGeometry",1132,G__G__Eve1_170_0_62, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGeoManager), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGeometryByAlias",1809,G__G__Eve1_170_0_63, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGeoManager), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - alias", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultGeometry",1841,G__G__Eve1_170_0_64, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGeoManager), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterGeometryAlias",2171,G__G__Eve1_170_0_65, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - alias u 'TString' - 11 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStatusLine",1336,G__G__Eve1_170_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearROOTClassSaved",1812,G__G__Eve1_170_0_67, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseEveWindow",1422,G__G__Eve1_170_0_68, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Create",596,G__G__Eve1_170_0_69, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveManager), -1, 0, 2, 3, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' map_window C - 'Option_t' 10 '\"FIV\"' opt", (char*)NULL, (void*) G__func2void( (TEveManager* (*)(Bool_t, Option_t*))(&TEveManager::Create) ), 0);
   G__memfunc_setup("Terminate",937,G__G__Eve1_170_0_70, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveManager::Terminate) ), 0);
   G__memfunc_setup("Class",502,G__G__Eve1_170_0_71, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveManager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_170_0_72, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveManager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_170_0_73, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveManager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_170_0_74, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveManager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_170_0_75, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_170_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Eve1_170_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve1_170_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve1_170_0_79, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveManager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_170_0_80, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveManager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_170_0_81, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveManager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_170_0_82, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveManager::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveManager", 1197, G__G__Eve1_170_0_83, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveElementcLcLTEveListTreeInfo(void) {
   /* TEveElement::TEveListTreeInfo */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLTEveListTreeInfo));
   G__memfunc_setup("TEveListTreeInfo",1580,G__G__Eve1_171_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLTEveListTreeInfo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveListTreeInfo",1580,G__G__Eve1_171_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLTEveListTreeInfo), -1, 0, 2, 1, 1, 0, 
"U 'TGListTree' - 0 - lt U 'TGListTreeItem' - 0 - lti", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveListTreeInfo",1580,G__G__Eve1_171_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLTEveListTreeInfo), -1, 0, 1, 1, 1, 0, "u 'TEveElement::TEveListTreeInfo' - 11 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Eve1_171_0_4, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementcLcLTEveListTreeInfo), -1, 1, 1, 1, 1, 0, "u 'TEveElement::TEveListTreeInfo' - 11 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Eve1_171_0_5, 103, -1, -1, 0, 1, 1, 1, 8, "u 'TEveElement::TEveListTreeInfo' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator<",936,G__G__Eve1_171_0_6, 103, -1, -1, 0, 1, 1, 1, 8, "u 'TEveElement::TEveListTreeInfo' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_171_0_7, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveElement::TEveListTreeInfo::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_171_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElement::TEveListTreeInfo::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_171_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveElement::TEveListTreeInfo::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_171_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveElement::TEveListTreeInfo::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_171_0_11, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_171_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__Eve1_171_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__Eve1_171_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__Eve1_171_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElement::TEveListTreeInfo::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_171_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveElement::TEveListTreeInfo::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_171_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElement::TEveListTreeInfo::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_171_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveElement::TEveListTreeInfo::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveListTreeInfo", 1706, G__G__Eve1_171_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfunclistlETEveElementmUcOallocatorlETEveElementmUgRsPgR(void) {
   /* list<TEveElement*,allocator<TEveElement*> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR));
   G__memfunc_setup("list<TEveElement*,allocator<TEveElement*> >",3981,G__G__Eve1_179_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__G__Eve1_179_0_2, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__G__Eve1_179_0_3, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__G__Eve1_179_0_4, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__G__Eve1_179_0_5, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__G__Eve1_179_0_6, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__G__Eve1_179_0_7, 104, -1, G__defined_typename("list<TEveElement*,allocator<TEveElement*> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__G__Eve1_179_0_8, 104, -1, G__defined_typename("list<TEveElement*,allocator<TEveElement*> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__G__Eve1_179_0_9, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__G__Eve1_179_0_10, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__G__Eve1_179_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'list<TEveElement*,allocator<TEveElement*> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Eve1_179_0_12, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 0 - position U 'TEveElement' - 41 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Eve1_179_0_13, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 0 - position U 'TEveElement' - 2 - first "
"U 'TEveElement' - 2 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Eve1_179_0_14, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 0 - position u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 0 - first "
"u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Eve1_179_0_15, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 0 - position h - 'list<TEveElement*,allocator<TEveElement*> >::size_type' 0 - n "
"U 'TEveElement' - 41 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_front",1096,G__G__Eve1_179_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 41 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__G__Eve1_179_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 41 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__G__Eve1_179_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'list<TEveElement*,allocator<TEveElement*> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__G__Eve1_179_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'list<TEveElement*,allocator<TEveElement*> >::size_type' 0 - n U 'TEveElement' - 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__G__Eve1_179_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__G__Eve1_179_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 0 - first u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__G__Eve1_179_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_front",983,G__G__Eve1_179_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__G__Eve1_179_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("list<TEveElement*,allocator<TEveElement*> >",3981,G__G__Eve1_179_0_25, 105, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR), -1, 0, 2, 1, 1, 0, 
"h - 'list<TEveElement*,allocator<TEveElement*> >::size_type' 0 - n U 'TEveElement' - 41 '(TEveElement*)()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("list<TEveElement*,allocator<TEveElement*> >",3981,G__G__Eve1_179_0_26, 105, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR), -1, 0, 2, 1, 1, 0, 
"U 'TEveElement' - 42 - first U 'TEveElement' - 42 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("list<TEveElement*,allocator<TEveElement*> >",3981,G__G__Eve1_179_0_27, 105, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'list<TEveElement*,allocator<TEveElement*> >::iterator' 'list<TEveElement*,allocator<TEveElement*> >::const_iterator' 10 - first u 'list<TEveElement*,allocator<TEveElement*> >::iterator' 'list<TEveElement*,allocator<TEveElement*> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("list<TEveElement*,allocator<TEveElement*> >",3981,G__G__Eve1_179_0_28, 105, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR), -1, 0, 1, 1, 1, 0, "u 'list<TEveElement*,allocator<TEveElement*> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Eve1_179_0_29, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR), -1, 1, 1, 1, 1, 0, "u 'list<TEveElement*,allocator<TEveElement*> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("splice",640,G__G__Eve1_179_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 0 - position u 'list<TEveElement*,allocator<TEveElement*> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("splice",640,G__G__Eve1_179_0_31, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 0 - position u 'list<TEveElement*,allocator<TEveElement*> >' - 1 - x "
"u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("splice",640,G__G__Eve1_179_0_32, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 0 - position u 'list<TEveElement*,allocator<TEveElement*> >' - 1 - x "
"u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 0 - first u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("remove",654,G__G__Eve1_179_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 41 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("unique",663,G__G__Eve1_179_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("merge",528,G__G__Eve1_179_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'list<TEveElement*,allocator<TEveElement*> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reverse",764,G__G__Eve1_179_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("sort",456,G__G__Eve1_179_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~list<TEveElement*,allocator<TEveElement*> >", 4107, G__G__Eve1_179_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfunclistlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator(void) {
   /* list<TEveElement*,allocator<TEveElement*> >::iterator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator));
   G__memfunc_setup("iterator",874,G__G__Eve1_180_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Eve1_180_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Eve1_180_0_3, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 1, 1, 1, 1, 0, "u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Eve1_180_0_4, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator->",983,G__G__Eve1_180_0_5, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 2, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Eve1_180_0_6, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Eve1_180_0_7, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "i - - 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Eve1_180_0_8, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Eve1_180_0_9, 117, G__get_linked_tagnum(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "i - - 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Eve1_180_0_10, 103, -1, -1, 0, 1, 1, 1, 0, "u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__G__Eve1_180_0_11, 103, -1, -1, 0, 1, 1, 1, 0, "u 'list<TEveElement*,allocator<TEveElement*> >::iterator' - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~iterator", 1000, G__G__Eve1_180_0_12, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveElementObjectPtr(void) {
   /* TEveElementObjectPtr */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementObjectPtr));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementObjectPtr), -1, 1, 1, 1, 4, 0, "u 'TEveElementObjectPtr' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveElementObjectPtr",1995,G__G__Eve1_185_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementObjectPtr), -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj g - 'Bool_t' 0 'kTRUE' own", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveElementObjectPtr",1995,G__G__Eve1_185_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementObjectPtr), -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - obj s - 'Color_t' 1 - mainColor "
"g - 'Bool_t' 0 'kTRUE' own", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveElementObjectPtr",1995,G__G__Eve1_185_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementObjectPtr), -1, 0, 1, 1, 1, 0, "u 'TEveElementObjectPtr' - 11 - e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloneElement",1211,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementObjectPtr), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetObject",887,G__G__Eve1_185_0_6, 85, G__get_linked_tagnum(&G__G__Eve1LN_TObject), -1, 0, 1, 1, 1, 8, "u 'TEveException' - 11 '\"TEveElementObjectPtr::GetObject \"' eh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExportToCINT",1139,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 0 - var_name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOwnObject",1195,G__G__Eve1_185_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOwnObject",1207,G__G__Eve1_185_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - o", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_185_0_10, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveElementObjectPtr::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_185_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElementObjectPtr::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_185_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveElementObjectPtr::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_185_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveElementObjectPtr::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_185_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__Eve1_185_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElementObjectPtr::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_185_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveElementObjectPtr::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_185_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElementObjectPtr::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_185_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveElementObjectPtr::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveElementObjectPtr", 2121, G__G__Eve1_185_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveElementList(void) {
   /* TEveElementList */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList), -1, 1, 1, 1, 4, 0, "u 'TEveElementList' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveElementList",1498,G__G__Eve1_186_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList), -1, 0, 4, 1, 1, 0, 
"C - - 10 '\"TEveElementList\"' n C - - 10 '\"\"' t "
"g - 'Bool_t' 0 'kFALSE' doColor g - 'Bool_t' 0 'kFALSE' doTransparency", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveElementList",1498,G__G__Eve1_186_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList), -1, 0, 1, 1, 1, 0, "u 'TEveElementList' - 11 - e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObject",887,G__G__Eve1_186_0_4, 85, G__get_linked_tagnum(&G__G__Eve1LN_TObject), -1, 0, 1, 1, 1, 8, "u 'TEveException' - 11 '\"TEveElementList::GetObject \"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloneElement",1211,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetElementName",1387,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetElementTitle",1516,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetElementName",1399,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetElementTitle",1528,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetElementNameTitle",1913,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetChildClass",1274,G__G__Eve1_186_0_11, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetChildClass",1286,G__G__Eve1_186_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AcceptElement",1306,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProjectedClass",1430,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 1, 1, 1, 8, "U 'TEveProjection' - 10 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_186_0_15, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveElementList::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_186_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElementList::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_186_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveElementList::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_186_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveElementList::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_186_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__Eve1_186_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElementList::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_186_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveElementList::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_186_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElementList::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_186_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveElementList::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveElementList", 1624, G__G__Eve1_186_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveElementListProjected(void) {
   /* TEveElementListProjected */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementListProjected));
   G__memfunc_setup("TEveElementListProjected",2426,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementListProjected), -1, 0, 1, 1, 4, 0, "u 'TEveElementListProjected' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementListProjected), -1, 1, 1, 1, 4, 0, "u 'TEveElementListProjected' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveElementListProjected",2426,G__G__Eve1_187_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementListProjected), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateProjection",1664,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetProjectedAsElement",2110,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_187_0_6, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveElementListProjected::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_187_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElementListProjected::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_187_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveElementListProjected::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_187_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveElementListProjected::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_187_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__Eve1_187_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElementListProjected::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_187_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveElementListProjected::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_187_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElementListProjected::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_187_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveElementListProjected::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveElementListProjected", 2552, G__G__Eve1_187_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGedEditor(void) {
   /* TEveGedEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor));
   G__memfunc_setup("TEveGedEditor",1259,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor), -1, 0, 1, 1, 4, 0, "u 'TEveGedEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor), -1, 1, 1, 1, 4, 0, "u 'TEveGedEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("CreateNameFrame",1472,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGedFrame), -1, 0, 2, 1, 2, 0, 
"U 'TGWindow' - 10 - parent C - - 10 - tab_name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TEveGedEditor",1259,G__G__Eve1_320_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor), -1, 0, 3, 1, 1, 0, 
"U 'TCanvas' - 0 '0' canvas h - 'UInt_t' 0 '250' width "
"h - 'UInt_t' 0 '400' height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteWindow",1227,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEveElement",1290,G__G__Eve1_320_0_7, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisplayElement",1440,G__G__Eve1_320_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - re", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisplayObject",1325,G__G__Eve1_320_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TVirtualPad' - 0 - pad U 'TObject' - 0 - obj "
"i - 'Int_t' 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGedFrame' - 0 '0' gframe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SpawnNewEditor",1434,G__G__Eve1_320_0_12, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) G__func2void( (void (*)(TObject*))(&TEveGedEditor::SpawnNewEditor) ), 0);
   G__memfunc_setup("ElementChanged",1396,G__G__Eve1_320_0_13, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) G__func2void( (void (*)(TEveElement*))(&TEveGedEditor::ElementChanged) ), 0);
   G__memfunc_setup("ElementDeleted",1409,G__G__Eve1_320_0_14, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) G__func2void( (void (*)(TEveElement*))(&TEveGedEditor::ElementDeleted) ), 0);
   G__memfunc_setup("DestroyEditors",1476,G__G__Eve1_320_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGedEditor::DestroyEditors) ), 0);
   G__memfunc_setup("GetContextMenu",1434,G__G__Eve1_320_0_16, 85, G__get_linked_tagnum(&G__G__Eve1LN_TContextMenu), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TContextMenu* (*)())(&TEveGedEditor::GetContextMenu) ), 0);
   G__memfunc_setup("Class",502,G__G__Eve1_320_0_17, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGedEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_320_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGedEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_320_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGedEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_320_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGedEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_320_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__Eve1_320_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGedEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_320_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGedEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_320_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGedEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_320_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGedEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGedEditor", 1385, G__G__Eve1_320_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveListTreeItem(void) {
   /* TEveListTreeItem */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveListTreeItem));
   G__memfunc_setup("TEveListTreeItem",1583,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveListTreeItem), -1, 0, 1, 1, 4, 0, "u 'TEveListTreeItem' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveListTreeItem), -1, 1, 1, 1, 4, 0, "u 'TEveListTreeItem' - 11 - -", "not implemented", (void*) NULL, 0);
   G__memfunc_setup("NotSupported",1271,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "C - - 10 - func", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveListTreeItem",1583,G__G__Eve1_321_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveListTreeItem), -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsActive",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetActiveColor",1403,(G__InterfaceMethod) NULL,107, -1, G__defined_typename("Pixel_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetActive",904,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetText",709,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTextLength",1319,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTipText",1010,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTipTextLength",1620,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetText",721,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTipText",1022,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUserData",1093,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - - g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUserData",1081,(G__InterfaceMethod) NULL,89, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPicture",1020,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TGPicture), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCheckBoxPicture",1795,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TGPicture), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPictures",1147,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGPicture' - 10 - - U 'TGPicture' - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCheckBoxPictures",1922,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGPicture' - 10 - - U 'TGPicture' - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCheckBox",1075,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasCheckBox",1059,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckItem",877,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Toggle",610,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsChecked",867,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasColor",795,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColor",799,(G__InterfaceMethod) NULL,115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColor",811,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearColor",998,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_321_0_29, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveListTreeItem::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_321_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveListTreeItem::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_321_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveListTreeItem::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_321_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveListTreeItem::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_321_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__Eve1_321_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveListTreeItem::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_321_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveListTreeItem::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_321_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveListTreeItem::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_321_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveListTreeItem::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveListTreeItem", 1709, G__G__Eve1_321_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGListTreeEditorFrame(void) {
   /* TEveGListTreeEditorFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGListTreeEditorFrame));
   G__memfunc_setup("TEveGListTreeEditorFrame",2361,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveGListTreeEditorFrame), -1, 0, 1, 1, 4, 0, "u 'TEveGListTreeEditorFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveGListTreeEditorFrame), -1, 1, 1, 1, 4, 0, "u 'TEveGListTreeEditorFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveGListTreeEditorFrame",2361,G__G__Eve1_322_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveGListTreeEditorFrame), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '250' width "
"i - 'Int_t' 0 '700' height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConnectSignals",1435,G__G__Eve1_322_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisconnectSignals",1755,G__G__Eve1_322_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReconfToHorizontal",1866,G__G__Eve1_322_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReconfToVertical",1626,G__G__Eve1_322_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListTree",1100,G__G__Eve1_322_0_8, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGListTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEditor",903,G__G__Eve1_322_0_9, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveGedEditor), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ItemBelowMouse",1425,G__G__Eve1_322_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - entry h - 'UInt_t' 0 - mask", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ItemClicked",1086,G__G__Eve1_322_0_11, 121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - entry i - 'Int_t' 0 - btn "
"h - 'UInt_t' 0 - mask i - 'Int_t' 0 - x "
"i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ItemDblClicked",1360,G__G__Eve1_322_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - item i - 'Int_t' 0 - btn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ItemKeyPress",1221,G__G__Eve1_322_0_13, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGListTreeItem' - 0 - entry h - 'UInt_t' 0 - keysym "
"h - 'UInt_t' 0 - mask", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEditorClass",1417,G__G__Eve1_322_0_14, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 - edclass", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TEveGListTreeEditorFrame::SetEditorClass) ), 0);
   G__memfunc_setup("Class",502,G__G__Eve1_322_0_15, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGListTreeEditorFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_322_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGListTreeEditorFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_322_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGListTreeEditorFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_322_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGListTreeEditorFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_322_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__Eve1_322_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGListTreeEditorFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_322_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGListTreeEditorFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_322_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGListTreeEditorFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_322_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGListTreeEditorFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGListTreeEditorFrame", 2487, G__G__Eve1_322_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveBrowser(void) {
   /* TEveBrowser */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser));
   G__memfunc_setup("TEveBrowser",1112,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser), -1, 0, 1, 1, 4, 0, "u 'TEveBrowser' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser), -1, 1, 1, 1, 4, 0, "u 'TEveBrowser' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("SetupCintExport",1569,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateReparentXY",1920,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"U 'TGObject' - 0 - parent i - 'Int_t' 1 - x "
"i - 'Int_t' 1 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveBrowser",1112,G__G__Eve1_323_0_5, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveBrowser), -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReallyDelete",1212,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitPlugins",1142,G__G__Eve1_323_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"FI\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeFileBrowser",1506,G__G__Eve1_323_0_8, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGFileBrowser), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFileBrowser",1412,G__G__Eve1_323_0_9, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGFileBrowser), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EveMenu",693,G__G__Eve1_323_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMenuBar",970,G__G__Eve1_323_0_11, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGMenuBar), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTopMenuFrame",1491,G__G__Eve1_323_0_12, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGHorizontalFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HideBottomTab",1286,G__G__Eve1_323_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_323_0_14, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveBrowser::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_323_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBrowser::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_323_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveBrowser::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_323_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveBrowser::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_323_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__Eve1_323_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBrowser::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_323_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveBrowser::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_323_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBrowser::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_323_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveBrowser::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveBrowser", 1238, G__G__Eve1_323_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveChunkManager(void) {
   /* TEveChunkManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManager));
   G__memfunc_setup("TEveChunkManager",1576,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManager), -1, 0, 1, 1, 4, 0, "u 'TEveChunkManager' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManager), -1, 1, 1, 1, 4, 0, "u 'TEveChunkManager' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("ReleaseChunks",1325,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveChunkManager",1576,G__G__Eve1_326_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManager), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveChunkManager",1576,G__G__Eve1_326_0_5, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManager), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - atom_size i - 'Int_t' 0 - chunk_size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Eve1_326_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - atom_size i - 'Int_t' 0 - chunk_size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Refit",506,G__G__Eve1_326_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("S",83,G__G__Eve1_326_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("N",78,G__G__Eve1_326_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Size",411,G__G__Eve1_326_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("VecSize",697,G__G__Eve1_326_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,G__G__Eve1_326_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Atom",401,G__G__Eve1_326_0_13, 67, -1, G__defined_typename("Char_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Chunk",505,G__G__Eve1_326_0_14, 67, -1, G__defined_typename("Char_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - chk", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NAtoms",594,G__G__Eve1_326_0_15, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - chk", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NewAtom",699,G__G__Eve1_326_0_16, 67, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NewChunk",803,G__G__Eve1_326_0_17, 67, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_326_0_18, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveChunkManager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_326_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveChunkManager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_326_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveChunkManager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_326_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveChunkManager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_326_0_22, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_326_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Eve1_326_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve1_326_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__Eve1_326_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveChunkManager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_326_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveChunkManager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_326_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveChunkManager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_326_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveChunkManager::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveChunkManager", 1702, G__G__Eve1_326_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveChunkManagercLcLiterator(void) {
   /* TEveChunkManager::iterator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManagercLcLiterator));
   G__memfunc_setup("iterator",874,G__G__Eve1_331_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManagercLcLiterator), -1, 0, 1, 1, 1, 0, "U 'TEveChunkManager' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Eve1_331_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManagercLcLiterator), -1, 0, 1, 1, 1, 0, "u 'TEveChunkManager' - 1 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Eve1_331_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManagercLcLiterator), -1, 0, 1, 1, 1, 0, "u 'TEveChunkManager::iterator' - 11 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Eve1_331_0_4, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveChunkManagercLcLiterator), -1, 1, 1, 1, 1, 0, "u 'TEveChunkManager::iterator' - 11 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("next",447,G__G__Eve1_331_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reset",547,G__G__Eve1_331_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Eve1_331_0_7, 67, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Eve1_331_0_8, 67, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("index",536,G__G__Eve1_331_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~iterator", 1000, G__G__Eve1_331_0_10, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCompoundProjected(void) {
   /* TEveCompoundProjected */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompoundProjected));
   G__memfunc_setup("TEveCompoundProjected",2137,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompoundProjected), -1, 0, 1, 1, 4, 0, "u 'TEveCompoundProjected' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompoundProjected), -1, 1, 1, 1, 4, 0, "u 'TEveCompoundProjected' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveCompoundProjected",2137,G__G__Eve1_339_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompoundProjected), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMainColor",1200,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - color", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateProjection",1664,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetProjectedAsElement",2110,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_339_0_7, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCompoundProjected::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_339_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompoundProjected::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_339_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCompoundProjected::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_339_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCompoundProjected::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_339_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__Eve1_339_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompoundProjected::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_339_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCompoundProjected::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_339_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompoundProjected::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_339_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCompoundProjected::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCompoundProjected", 2263, G__G__Eve1_339_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTransSubEditor(void) {
   /* TEveTransSubEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransSubEditor));
   G__memfunc_setup("TEveTransSubEditor",1805,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveTransSubEditor), -1, 0, 1, 1, 4, 0, "u 'TEveTransSubEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveTransSubEditor), -1, 1, 1, 1, 4, 0, "u 'TEveTransSubEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveTransSubEditor",1805,G__G__Eve1_349_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveTransSubEditor), -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,G__G__Eve1_349_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveTrans' - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTransFromData",1602,G__G__Eve1_349_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseTrans",821,G__G__Eve1_349_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("TransChanged",1202,G__G__Eve1_349_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("DoUseTrans",1000,G__G__Eve1_349_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoEditTrans",1089,G__G__Eve1_349_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoTransChanged",1381,G__G__Eve1_349_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosValuator",1440,G__G__Eve1_349_0_11, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRotValuator",1443,G__G__Eve1_349_0_12, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScaleValuator",1622,G__G__Eve1_349_0_13, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_349_0_14, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTransSubEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_349_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTransSubEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_349_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTransSubEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_349_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTransSubEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_349_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__Eve1_349_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTransSubEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_349_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTransSubEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_349_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTransSubEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_349_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTransSubEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTransSubEditor", 1931, G__G__Eve1_349_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveElementEditor(void) {
   /* TEveElementEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveElementEditor));
   G__memfunc_setup("TEveElementEditor",1701,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementEditor), -1, 0, 1, 1, 4, 0, "u 'TEveElementEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementEditor), -1, 1, 1, 1, 4, 0, "u 'TEveElementEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveElementEditor",1701,G__G__Eve1_350_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveElementEditor), -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("DoRnrSelf",879,G__G__Eve1_350_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRnrChildren",1294,G__G__Eve1_350_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRnrState",998,G__G__Eve1_350_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoMainColor",1079,G__G__Eve1_350_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoTransparency",1453,G__G__Eve1_350_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_350_0_10, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveElementEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_350_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElementEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_350_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveElementEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_350_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveElementEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_350_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__Eve1_350_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElementEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_350_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveElementEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_350_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveElementEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_350_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveElementEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveElementEditor", 1827, G__G__Eve1_350_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveEventManager(void) {
   /* TEveEventManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveEventManager));
   G__memfunc_setup("TEveEventManager",1585,G__G__Eve1_351_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveEventManager), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEveEventManager\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNewEventCommands",1918,G__G__Eve1_351_0_2, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETStringcOallocatorlETStringgRsPgR), G__defined_typename("vector<TString>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Open",402,G__G__Eve1_351_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GotoEvent",923,G__G__Eve1_351_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NextEvent",929,G__G__Eve1_351_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrevEvent",927,G__G__Eve1_351_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Close",502,G__G__Eve1_351_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AfterNewEventLoaded",1895,G__G__Eve1_351_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddNewEventCommand",1780,G__G__Eve1_351_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - cmd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveNewEventCommand",2137,G__G__Eve1_351_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - cmd", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearNewEventCommands",2117,G__G__Eve1_351_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_351_0_12, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveEventManager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_351_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveEventManager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_351_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveEventManager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_351_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveEventManager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_351_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__Eve1_351_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveEventManager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_351_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveEventManager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_351_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveEventManager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_351_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveEventManager::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveEventManager", 1711, G__G__Eve1_351_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGValuatorBase(void) {
   /* TEveGValuatorBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuatorBase));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuatorBase), -1, 1, 1, 1, 4, 0, "u 'TEveGValuatorBase' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("Build",496,G__G__Eve1_377_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' connect", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetLabelWidth",1292,G__G__Eve1_377_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAlignRight",1301,G__G__Eve1_377_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShowSlider",1328,G__G__Eve1_377_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNELength",1057,G__G__Eve1_377_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNEHeight",1048,G__G__Eve1_377_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLabel",768,G__G__Eve1_377_0_10, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGLabel), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_377_0_11, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGValuatorBase::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_377_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGValuatorBase::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_377_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGValuatorBase::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_377_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGValuatorBase::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_377_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__Eve1_377_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGValuatorBase::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_377_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGValuatorBase::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_377_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGValuatorBase::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_377_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGValuatorBase::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGValuatorBase", 1794, G__G__Eve1_377_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGValuator(void) {
   /* TEveGValuator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator));
   G__memfunc_setup("TEveGValuator",1289,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator), -1, 0, 1, 1, 4, 0, "u 'TEveGValuator' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator), -1, 1, 1, 1, 4, 0, "u 'TEveGValuator' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("CalcSliderPos",1288,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "f - 'Float_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveGValuator",1289,G__G__Eve1_378_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 - p C - - 10 - title "
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h "
"i - 'Int_t' 0 '-1' widgetId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Build",496,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' connect", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValue",797,G__G__Eve1_378_0_6, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValue",809,G__G__Eve1_378_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - v g - 'Bool_t' 0 'kFALSE' emit", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SliderCallback",1392,G__G__Eve1_378_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EntryCallback",1311,G__G__Eve1_378_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValueSet",809,G__G__Eve1_378_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("GetSlider",899,G__G__Eve1_378_0_11, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGHSlider), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntry",818,G__G__Eve1_378_0_12, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGNumberEntry), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSliderNewLine",1601,G__G__Eve1_378_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - nl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLimits",914,G__G__Eve1_378_0_14, 121, -1, -1, 0, 2, 1, 1, 8, 
"f - 'Float_t' 1 - min f - 'Float_t' 1 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLimitMin",1091,G__G__Eve1_378_0_15, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLimitMax",1093,G__G__Eve1_378_0_16, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLimits",926,G__G__Eve1_378_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - min i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLimits",926,G__G__Eve1_378_0_18, 121, -1, -1, 0, 4, 1, 1, 0, 
"f - 'Float_t' 0 - min f - 'Float_t' 0 - max "
"i - 'Int_t' 0 - npos i 'TGNumberFormat::EStyle' - 0 'TGNumberFormat::kNESRealTwo' nef", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetToolTip",1015,G__G__Eve1_378_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - tip", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEnabled",983,G__G__Eve1_378_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_378_0_21, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGValuator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_378_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGValuator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_378_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGValuator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_378_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGValuator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_378_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__Eve1_378_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGValuator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_378_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGValuator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_378_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGValuator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_378_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGValuator::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGValuator", 1415, G__G__Eve1_378_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGDoubleValuator(void) {
   /* TEveGDoubleValuator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGDoubleValuator));
   G__memfunc_setup("TEveGDoubleValuator",1892,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveGDoubleValuator), -1, 0, 1, 1, 4, 0, "u 'TEveGDoubleValuator' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveGDoubleValuator), -1, 1, 1, 1, 4, 0, "u 'TEveGDoubleValuator' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveGDoubleValuator",1892,G__G__Eve1_379_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveGDoubleValuator), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 - p C - - 10 - title "
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h "
"i - 'Int_t' 0 '-1' widgetId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Build",496,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' connect", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MinEntryCallback",1603,G__G__Eve1_379_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MaxEntryCallback",1605,G__G__Eve1_379_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SliderCallback",1392,G__G__Eve1_379_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValueSet",809,G__G__Eve1_379_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("GetSlider",899,G__G__Eve1_379_0_9, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGDoubleHSlider), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinEntry",1110,G__G__Eve1_379_0_10, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGNumberEntry), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxEntry",1112,G__G__Eve1_379_0_11, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGNumberEntry), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLimits",926,G__G__Eve1_379_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - min i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLimits",926,G__G__Eve1_379_0_13, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - min f - 'Float_t' 0 - max "
"i 'TGNumberFormat::EStyle' - 0 'TGNumberFormat::kNESRealTwo' nef", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValues",924,G__G__Eve1_379_0_14, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - min f - 'Float_t' 0 - max "
"g - 'Bool_t' 0 'kFALSE' emit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValues",912,G__G__Eve1_379_0_15, 121, -1, -1, 0, 2, 1, 1, 8, 
"f - 'Float_t' 1 - min f - 'Float_t' 1 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMin",580,G__G__Eve1_379_0_16, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMax",582,G__G__Eve1_379_0_17, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLimitMin",1091,G__G__Eve1_379_0_18, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLimitMax",1093,G__G__Eve1_379_0_19, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_379_0_20, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGDoubleValuator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_379_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGDoubleValuator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_379_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGDoubleValuator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_379_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGDoubleValuator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_379_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__Eve1_379_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGDoubleValuator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_379_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGDoubleValuator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_379_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGDoubleValuator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_379_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGDoubleValuator::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGDoubleValuator", 2018, G__G__Eve1_379_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGTriVecValuator(void) {
   /* TEveGTriVecValuator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator));
   G__memfunc_setup("TEveGTriVecValuator",1878,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator), -1, 0, 1, 1, 4, 0, "u 'TEveGTriVecValuator' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator), -1, 1, 1, 1, 4, 0, "u 'TEveGTriVecValuator' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveGTriVecValuator",1878,G__G__Eve1_380_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveGTriVecValuator), -1, 0, 5, 1, 1, 0, 
"U 'TGWindow' - 10 - p C - - 10 - name "
"h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h "
"i - 'Int_t' 0 '-1' widgetId", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Build",496,G__G__Eve1_380_0_4, 121, -1, -1, 0, 4, 1, 1, 0, 
"g - 'Bool_t' 0 - vertical C - - 10 - lab0 "
"C - - 10 - lab1 C - - 10 - lab2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValuator",1134,G__G__Eve1_380_0_5, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveGValuator), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValue",797,G__G__Eve1_380_0_6, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValue",809,G__G__Eve1_380_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - i f - 'Float_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValues",912,G__G__Eve1_380_0_8, 121, -1, -1, 0, 3, 1, 1, 8, 
"f - 'Float_t' 1 - v0 f - 'Float_t' 1 - v1 "
"f - 'Float_t' 1 - v2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValues",912,G__G__Eve1_380_0_9, 121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValues",912,G__G__Eve1_380_0_10, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValues",924,G__G__Eve1_380_0_11, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - v0 f - 'Float_t' 0 - v1 "
"f - 'Float_t' 0 - v2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValues",924,G__G__Eve1_380_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValues",924,G__G__Eve1_380_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValueSet",809,G__G__Eve1_380_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("SetLabelWidth",1292,G__G__Eve1_380_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNELength",1057,G__G__Eve1_380_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNEHeight",1048,G__G__Eve1_380_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLimits",926,G__G__Eve1_380_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - min i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLimits",926,G__G__Eve1_380_0_19, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - min f - 'Float_t' 0 - max "
"i 'TGNumberFormat::EStyle' - 0 'TGNumberFormat::kNESRealTwo' nef", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_380_0_20, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGTriVecValuator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_380_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGTriVecValuator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_380_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGTriVecValuator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_380_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGTriVecValuator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_380_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__Eve1_380_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGTriVecValuator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_380_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGTriVecValuator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_380_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGTriVecValuator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_380_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGTriVecValuator::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGTriVecValuator", 2004, G__G__Eve1_380_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGedNameFrame(void) {
   /* TEveGedNameFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameFrame));
   G__memfunc_setup("TEveGedNameFrame",1520,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameFrame), -1, 0, 1, 1, 4, 0, "u 'TEveGedNameFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameFrame), -1, 1, 1, 1, 4, 0, "u 'TEveGedNameFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveGedNameFrame",1520,G__G__Eve1_389_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameFrame), -1, 0, 4, 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|kHorizontalFrame' options", (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("SpawnEditorClone",1633,G__G__Eve1_389_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_389_0_6, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGedNameFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_389_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGedNameFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_389_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGedNameFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_389_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGedNameFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_389_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__Eve1_389_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGedNameFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_389_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGedNameFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_389_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGedNameFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_389_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGedNameFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGedNameFrame", 1646, G__G__Eve1_389_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGedNameTextButton(void) {
   /* TEveGedNameTextButton */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameTextButton));
   G__memfunc_setup("TEveGedNameTextButton",2086,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameTextButton), -1, 0, 1, 1, 4, 0, "u 'TEveGedNameTextButton' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameTextButton), -1, 1, 1, 1, 4, 0, "u 'TEveGedNameTextButton' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveGedNameTextButton",2086,G__G__Eve1_390_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveGedNameTextButton), -1, 0, 1, 1, 1, 0, "U 'TEveGedNameFrame' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_390_0_5, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGedNameTextButton::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_390_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGedNameTextButton::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_390_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGedNameTextButton::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_390_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGedNameTextButton::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_390_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__Eve1_390_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGedNameTextButton::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_390_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGedNameTextButton::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_390_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGedNameTextButton::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_390_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGedNameTextButton::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGedNameTextButton", 2212, G__G__Eve1_390_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveMacro(void) {
   /* TEveMacro */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveMacro));
   G__memfunc_setup("TEveMacro",870,G__G__Eve1_393_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveMacro), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveMacro",870,G__G__Eve1_393_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveMacro), -1, 0, 1, 1, 1, 0, "u 'TEveMacro' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveMacro",870,G__G__Eve1_393_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveMacro), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Exec",389,(G__InterfaceMethod) NULL,108, -1, G__defined_typename("Long_t"), 0, 2, 1, 1, 0, 
"C - - 10 '\"0\"' params I - 'Int_t' 0 '0' error", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetRoot",935,G__G__Eve1_393_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_393_0_6, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveMacro::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_393_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMacro::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_393_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveMacro::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_393_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveMacro::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_393_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__Eve1_393_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMacro::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_393_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveMacro::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_393_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMacro::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_393_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveMacro::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveMacro", 996, G__G__Eve1_393_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_393_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveMacro), -1, 1, 1, 1, 1, 0, "u 'TEveMacro' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveSelection(void) {
   /* TEveSelection */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection));
   G__memfunc_setup("TEveSelection",1306,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection), -1, 0, 1, 1, 4, 0, "u 'TEveSelection' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection), -1, 1, 1, 1, 4, 0, "u 'TEveSelection' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("DoElementSelect",1501,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'map<TEveElement*,set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >,less<TEveElement*>,allocator<pair<TEveElement* const,set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> > > > >::iterator' 'TEveSelection::SelMap_i' 0 - entry", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoElementUnselect",1728,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'map<TEveElement*,set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >,less<TEveElement*>,allocator<pair<TEveElement* const,set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> > > > >::iterator' 'TEveSelection::SelMap_i' 0 - entry", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RecheckImpliedSet",1701,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'map<TEveElement*,set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >,less<TEveElement*>,allocator<pair<TEveElement* const,set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> > > > >::iterator' 'TEveSelection::SelMap_i' 0 - smi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveSelection",1306,G__G__Eve1_415_0_6, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveSelection), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEveSelection\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHighlightMode",1609,G__G__Eve1_415_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPickToSelect",1482,G__G__Eve1_415_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPickToSelect",1494,G__G__Eve1_415_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ps", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIsMaster",1096,G__G__Eve1_415_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIsMaster",1108,G__G__Eve1_415_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AcceptElement",1306,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddElement",979,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveElement",1336,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveElementLocal",1827,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveElements",1451,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveElementsLocal",1942,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveImpliedSelected",2139,G__G__Eve1_415_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RecheckImpliedSetForElement",2710,G__G__Eve1_415_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectionAdded",1400,G__G__Eve1_415_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("SelectionRemoved",1656,G__G__Eve1_415_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("SelectionCleared",1622,G__G__Eve1_415_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("SelectionRepeated",1744,G__G__Eve1_415_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("ActivateSelection",1751,G__G__Eve1_415_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeactivateSelection",1952,G__G__Eve1_415_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MapPickedToSelected",1882,G__G__Eve1_415_0_26, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveElement), -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UserPickedElement",1721,G__G__Eve1_415_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveElement' - 0 - el g - 'Bool_t' 0 'kFALSE' multi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UserRePickedElement",1904,G__G__Eve1_415_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UserUnPickedElement",1916,G__G__Eve1_415_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_415_0_30, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveSelection::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_415_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveSelection::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_415_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveSelection::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_415_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveSelection::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_415_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__Eve1_415_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveSelection::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_415_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveSelection::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_415_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveSelection::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_415_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveSelection::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveSelection", 1432, G__G__Eve1_415_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveViewer(void) {
   /* TEveViewer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer));
   G__memfunc_setup("TEveViewer",998,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer), -1, 0, 1, 1, 4, 0, "u 'TEveViewer' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer), -1, 1, 1, 1, 4, 0, "u 'TEveViewer' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("InitInternal",1233,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 3, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveViewer",998,G__G__Eve1_416_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEveViewer\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PreUndock",907,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PostDock",807,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGLViewer",1061,G__G__Eve1_416_0_7, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGLViewer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGLViewer",1073,G__G__Eve1_416_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGLViewer' - 0 - viewer U 'TGFrame' - 0 - frame", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SpawnGLViewer",1294,G__G__Eve1_416_0_9, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGLSAViewer), -1, 0, 2, 1, 1, 0, 
"U 'TGedEditor' - 0 '0' ged g - 'Bool_t' 0 'kFALSE' stereo", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SpawnGLEmbeddedViewer",2072,G__G__Eve1_416_0_10, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGLEmbeddedViewer), -1, 0, 2, 1, 1, 0, 
"U 'TGedEditor' - 0 '0' ged i - 'Int_t' 0 '0' border", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Redraw",613,G__G__Eve1_416_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' resetCameras", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SwitchStereo",1252,G__G__Eve1_416_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddScene",759,G__G__Eve1_416_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveScene' - 0 - scene", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveElementLocal",1827,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveElementsLocal",1942,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEditorObject",1502,G__G__Eve1_416_0_16, 85, G__get_linked_tagnum(&G__G__Eve1LN_TObject), -1, 0, 1, 1, 1, 8, "u 'TEveException' - 11 '\"TEveViewer::GetEditorObject \"' eh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleElementPaste",1811,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListTreeIcon",1493,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TGPicture), -1, 0, 1, 1, 1, 1, "g - 'Bool_t' 0 'kFALSE' open", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_416_0_19, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveViewer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_416_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveViewer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_416_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveViewer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_416_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveViewer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_416_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__Eve1_416_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveViewer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_416_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveViewer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_416_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveViewer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_416_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveViewer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveViewer", 1124, G__G__Eve1_416_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveViewerList(void) {
   /* TEveViewerList */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerList));
   G__memfunc_setup("TEveViewerList",1410,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerList), -1, 0, 1, 1, 4, 0, "u 'TEveViewerList' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerList), -1, 1, 1, 1, 4, 0, "u 'TEveViewerList' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("HandleTooltip",1335,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveViewerList",1410,G__G__Eve1_417_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerList), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEveViewerList\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddElement",979,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveElementLocal",1827,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RemoveElementsLocal",1942,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Connect",714,G__G__Eve1_417_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Disconnect",1034,G__G__Eve1_417_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RepaintChangedViewers",2146,G__G__Eve1_417_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - resetCameras g - 'Bool_t' 0 - dropLogicals", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RepaintAllViewers",1745,G__G__Eve1_417_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - resetCameras g - 'Bool_t' 0 - dropLogicals", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteAnnotations",1761,G__G__Eve1_417_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SceneDestructing",1658,G__G__Eve1_417_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveScene' - 0 - scene", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OnMouseOver",1122,G__G__Eve1_417_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj h - 'UInt_t' 0 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OnReMouseOver",1305,G__G__Eve1_417_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj h - 'UInt_t' 0 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OnUnMouseOver",1317,G__G__Eve1_417_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj h - 'UInt_t' 0 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OnClicked",876,G__G__Eve1_417_0_17, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - obj h - 'UInt_t' 0 - button "
"h - 'UInt_t' 0 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OnReClicked",1059,G__G__Eve1_417_0_18, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - obj h - 'UInt_t' 0 - button "
"h - 'UInt_t' 0 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OnUnClicked",1071,G__G__Eve1_417_0_19, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TObject' - 0 - obj h - 'UInt_t' 0 - button "
"h - 'UInt_t' 0 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShowTooltip",1452,G__G__Eve1_417_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShowTooltip",1464,G__G__Eve1_417_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColorBrightness",1848,G__G__Eve1_417_0_22, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetColorBrightness",1860,G__G__Eve1_417_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseLightColorSet",1616,G__G__Eve1_417_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SwitchColorSet",1437,G__G__Eve1_417_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_417_0_26, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveViewerList::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_417_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveViewerList::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_417_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveViewerList::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_417_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveViewerList::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_417_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__Eve1_417_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveViewerList::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_417_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveViewerList::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_417_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveViewerList::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_417_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveViewerList::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveViewerList", 1536, G__G__Eve1_417_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveScene(void) {
   /* TEveScene */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveScene));
   G__memfunc_setup("TEveScene",866,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveScene), -1, 0, 1, 1, 4, 0, "u 'TEveScene' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveScene), -1, 1, 1, 1, 4, 0, "u 'TEveScene' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("RetransHierarchicallyRecurse",2908,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TEveElement' - 0 - el u 'TEveTrans' - 11 - tp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveScene",866,G__G__Eve1_418_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveScene), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEveScene\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CollectSceneParents",1937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'list<TEveElement*,allocator<TEveElement*> >' 'TEveElement::List_t' 1 - scenes", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SingleRnrState",1429,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Changed",682,G__G__Eve1_418_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsChanged",870,G__G__Eve1_418_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHierarchical",1515,G__G__Eve1_418_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHierarchical",1503,G__G__Eve1_418_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Repaint",723,G__G__Eve1_418_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' dropLogicals", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RetransHierarchically",2179,G__G__Eve1_418_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGLScene",929,G__G__Eve1_418_0_13, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGLScenePad), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGLScene",941,G__G__Eve1_418_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLScenePad' - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - n", (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("DestroyElementRenderers",2398,G__G__Eve1_418_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - element", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DestroyElementRenderers",2398,G__G__Eve1_418_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - rnrObj", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListTreeIcon",1493,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TGPicture), -1, 0, 1, 1, 1, 1, "g - 'Bool_t' 0 'kFALSE' open", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_418_0_20, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveScene::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_418_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveScene::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_418_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveScene::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_418_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveScene::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_418_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__Eve1_418_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveScene::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_418_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveScene::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_418_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveScene::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_418_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveScene::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveScene", 992, G__G__Eve1_418_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveSceneList(void) {
   /* TEveSceneList */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneList));
   G__memfunc_setup("TEveSceneList",1278,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneList), -1, 0, 1, 1, 4, 0, "u 'TEveSceneList' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneList), -1, 1, 1, 1, 4, 0, "u 'TEveSceneList' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveSceneList",1278,G__G__Eve1_419_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneList), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEveSceneList\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DestroyScenes",1355,G__G__Eve1_419_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RepaintChangedScenes",2014,G__G__Eve1_419_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - dropLogicals", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RepaintAllScenes",1613,G__G__Eve1_419_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - dropLogicals", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DestroyElementRenderers",2398,G__G__Eve1_419_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - element", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessSceneChanges",1926,G__G__Eve1_419_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - dropLogicals U 'TExMap' - 0 - stampMap", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_419_0_9, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveSceneList::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_419_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveSceneList::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_419_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveSceneList::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_419_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveSceneList::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_419_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__Eve1_419_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveSceneList::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_419_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveSceneList::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_419_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveSceneList::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_419_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveSceneList::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveSceneList", 1404, G__G__Eve1_419_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveWindowManager(void) {
   /* TEveWindowManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowManager));
   G__memfunc_setup("TEveWindowManager",1703,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowManager), -1, 0, 1, 1, 4, 0, "u 'TEveWindowManager' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowManager), -1, 1, 1, 1, 4, 0, "u 'TEveWindowManager' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("DestroyWindowRecursively",2559,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TEveWindow' - 0 - window", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveWindowManager",1703,G__G__Eve1_420_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowManager), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEveWindowManager\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectWindow",1240,G__G__Eve1_420_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveWindow' - 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteWindow",1227,G__G__Eve1_420_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveWindow' - 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WindowDocked",1218,G__G__Eve1_420_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveWindow' - 0 - window", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("WindowUndocked",1445,G__G__Eve1_420_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveWindow' - 0 - window", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("WindowSelected",1441,G__G__Eve1_420_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveWindow' - 0 - window", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("WindowDeleted",1327,G__G__Eve1_420_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveWindow' - 0 - window", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("GetCurrentWindow",1659,G__G__Eve1_420_0_11, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCurrentWindow",1559,G__G__Eve1_420_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TEveWindow' - 10 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentWindowAsSlot",2257,G__G__Eve1_420_0_13, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultContainer",1928,G__G__Eve1_420_0_14, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasDefaultContainer",1924,G__G__Eve1_420_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDefaultContainer",1940,G__G__Eve1_420_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveWindow' - 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DestroyWindows",1493,G__G__Eve1_420_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HideAllEveDecorations",2094,G__G__Eve1_420_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShowNormalEveDecorations",2469,G__G__Eve1_420_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShowTitleBars",1623,G__G__Eve1_420_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_420_0_21, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveWindowManager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_420_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowManager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_420_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveWindowManager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_420_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveWindowManager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_420_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__Eve1_420_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowManager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_420_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveWindowManager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_420_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowManager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_420_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveWindowManager::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveWindowManager", 1829, G__G__Eve1_420_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveManagercLcLTRedrawDisabler(void) {
   /* TEveManager::TRedrawDisabler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveManagercLcLTRedrawDisabler));
   G__memfunc_setup("TRedrawDisabler",1503,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveManagercLcLTRedrawDisabler), -1, 0, 1, 1, 4, 0, "u 'TEveManager::TRedrawDisabler' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveManagercLcLTRedrawDisabler), -1, 1, 1, 1, 4, 0, "u 'TEveManager::TRedrawDisabler' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TRedrawDisabler",1503,G__G__Eve1_421_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveManagercLcLTRedrawDisabler), -1, 0, 1, 1, 1, 0, "U 'TEveManager' - 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_421_0_4, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveManager::TRedrawDisabler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_421_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveManager::TRedrawDisabler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_421_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveManager::TRedrawDisabler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_421_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveManager::TRedrawDisabler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_421_0_8, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_421_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__Eve1_421_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__Eve1_421_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__Eve1_421_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveManager::TRedrawDisabler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_421_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveManager::TRedrawDisabler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_421_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveManager::TRedrawDisabler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_421_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveManager::TRedrawDisabler::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TRedrawDisabler", 1629, G__G__Eve1_421_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveManagercLcLTExceptionHandler(void) {
   /* TEveManager::TExceptionHandler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveManagercLcLTExceptionHandler));
   G__memfunc_setup("TExceptionHandler",1729,G__G__Eve1_422_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveManagercLcLTExceptionHandler), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Handle",588,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__G__Eve1LN_TStdExceptionHandlercLcLEStatus), -1, 0, 1, 1, 1, 0, "u 'exception' - 1 - exc", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_422_0_3, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveManager::TExceptionHandler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_422_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveManager::TExceptionHandler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_422_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveManager::TExceptionHandler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_422_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveManager::TExceptionHandler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_422_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__Eve1_422_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveManager::TExceptionHandler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_422_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveManager::TExceptionHandler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_422_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveManager::TExceptionHandler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_422_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveManager::TExceptionHandler::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TExceptionHandler", 1855, G__G__Eve1_422_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvePad(void) {
   /* TEvePad */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePad));
   G__memfunc_setup("TEvePad",649,G__G__Eve1_427_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEvePad), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEvePad",649,G__G__Eve1_427_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEvePad), -1, 0, 9, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"d - 'Double_t' 0 - xlow d - 'Double_t' 0 - ylow "
"d - 'Double_t' 0 - xup d - 'Double_t' 0 - yup "
"s - 'Color_t' 0 '-1' color s - 'Short_t' 0 '-1' bordersize "
"s - 'Short_t' 0 '-2' bordermode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsBatch",670,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Update",611,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetViewer3D",1033,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TVirtualViewer3D), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_427_0_6, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvePad::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_427_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePad::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_427_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvePad::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_427_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvePad::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_427_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__Eve1_427_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePad::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_427_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePad::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_427_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePad::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_427_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePad::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEvePad", 775, G__G__Eve1_427_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveParamList(void) {
   /* TEveParamList */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList));
   G__memfunc_setup("TEveParamList",1281,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList), -1, 0, 1, 1, 4, 0, "u 'TEveParamList' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList), -1, 1, 1, 1, 4, 0, "u 'TEveParamList' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveParamList",1281,G__G__Eve1_428_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveParamList), -1, 0, 3, 1, 1, 0, 
"C - - 10 '\"TEveParamList\"' n C - - 10 '\"\"' t "
"g - 'Bool_t' 0 'kFALSE' doColor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddParameter",1194,G__G__Eve1_428_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEveParamList::FloatConfig_t' - 11 - parameter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddParameter",1194,G__G__Eve1_428_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEveParamList::IntConfig_t' - 11 - parameter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddParameter",1194,G__G__Eve1_428_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEveParamList::BoolConfig_t' - 11 - parameter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFloatParameters",1834,G__G__Eve1_428_0_7, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgR), G__defined_typename("TEveParamList::FloatConfigVec_t"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIntParameters",1631,G__G__Eve1_428_0_8, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgR), G__defined_typename("TEveParamList::IntConfigVec_t"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBoolParameters",1728,G__G__Eve1_428_0_9, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgR), G__defined_typename("TEveParamList::BoolConfigVec_t"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFloatParameter",1719,G__G__Eve1_428_0_10, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLFloatConfig_t), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIntParameter",1516,G__G__Eve1_428_0_11, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLIntConfig_t), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBoolParameter",1613,G__G__Eve1_428_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TString' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ParamChanged",1179,G__G__Eve1_428_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_428_0_14, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveParamList::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_428_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveParamList::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_428_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveParamList::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_428_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveParamList::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_428_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__Eve1_428_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveParamList::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_428_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveParamList::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_428_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveParamList::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_428_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveParamList::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveParamList", 1407, G__G__Eve1_428_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveParamListEditor(void) {
   /* TEveParamListEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListEditor));
   G__memfunc_setup("TEveParamListEditor",1896,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListEditor), -1, 0, 1, 1, 4, 0, "u 'TEveParamListEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListEditor), -1, 1, 1, 1, 4, 0, "u 'TEveParamListEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("InitModel",901,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TEveParamListEditor",1896,G__G__Eve1_429_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListEditor), -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("DoIntUpdate",1089,G__G__Eve1_429_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoFloatUpdate",1292,G__G__Eve1_429_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoBoolUpdate",1186,G__G__Eve1_429_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_429_0_9, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveParamListEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_429_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveParamListEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_429_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveParamListEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_429_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveParamListEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_429_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__Eve1_429_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveParamListEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_429_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveParamListEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_429_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveParamListEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_429_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveParamListEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveParamListEditor", 2022, G__G__Eve1_429_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveParamListcLcLFloatConfig_t(void) {
   /* TEveParamList::FloatConfig_t */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLFloatConfig_t));
   G__memfunc_setup("FloatConfig_t",1311,G__G__Eve1_430_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLFloatConfig_t), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 0 - name d - 'Double_t' 0 - value "
"d - 'Double_t' 0 - min d - 'Double_t' 0 - max "
"g - 'Bool_t' 0 'kFALSE' selector", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FloatConfig_t",1311,G__G__Eve1_430_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLFloatConfig_t), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("FloatConfig_t", 1311, G__G__Eve1_430_0_3, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLFloatConfig_t), -1, 0, 1, 1, 1, 0, "u 'TEveParamList::FloatConfig_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~FloatConfig_t", 1437, G__G__Eve1_430_0_4, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_430_0_5, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLFloatConfig_t), -1, 1, 1, 1, 1, 0, "u 'TEveParamList::FloatConfig_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveParamListcLcLIntConfig_t(void) {
   /* TEveParamList::IntConfig_t */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLIntConfig_t));
   G__memfunc_setup("IntConfig_t",1108,G__G__Eve1_435_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLIntConfig_t), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 0 - name i - 'Int_t' 0 - value "
"i - 'Int_t' 0 - min i - 'Int_t' 0 - max "
"g - 'Bool_t' 0 'kFALSE' selector", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntConfig_t",1108,G__G__Eve1_435_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLIntConfig_t), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("IntConfig_t", 1108, G__G__Eve1_435_0_3, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLIntConfig_t), -1, 0, 1, 1, 1, 0, "u 'TEveParamList::IntConfig_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~IntConfig_t", 1234, G__G__Eve1_435_0_4, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_435_0_5, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLIntConfig_t), -1, 1, 1, 1, 1, 0, "u 'TEveParamList::IntConfig_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveParamListcLcLBoolConfig_t(void) {
   /* TEveParamList::BoolConfig_t */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLBoolConfig_t));
   G__memfunc_setup("BoolConfig_t",1205,G__G__Eve1_440_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLBoolConfig_t), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 0 - name g - 'Bool_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BoolConfig_t",1205,G__G__Eve1_440_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLBoolConfig_t), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("BoolConfig_t", 1205, G__G__Eve1_440_0_3, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLBoolConfig_t), -1, 0, 1, 1, 1, 0, "u 'TEveParamList::BoolConfig_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BoolConfig_t", 1331, G__G__Eve1_440_0_4, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_440_0_5, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveParamListcLcLBoolConfig_t), -1, 1, 1, 1, 1, 0, "u 'TEveParamList::BoolConfig_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveProjectionAxes(void) {
   /* TEveProjectionAxes */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxes));
   G__memfunc_setup("TEveProjectionAxes",1826,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxes), -1, 0, 1, 1, 4, 0, "u 'TEveProjectionAxes' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxes), -1, 1, 1, 1, 4, 0, "u 'TEveProjectionAxes' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveProjectionAxes",1826,G__G__Eve1_454_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxes), -1, 0, 2, 1, 1, 0, 
"U 'TEveProjectionManager' - 0 - m g - 'Bool_t' 0 'kTRUE' useColorSet", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetManager",987,G__G__Eve1_454_0_4, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManager), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLabMode",960,G__G__Eve1_454_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TEveProjectionAxes::ELabMode' - 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLabMode",948,G__G__Eve1_454_0_6, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxescLcLELabMode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAxesMode",1090,G__G__Eve1_454_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TEveProjectionAxes::EAxesMode' - 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAxesMode",1078,G__G__Eve1_454_0_8, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxescLcLEAxesMode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawCenter",1307,G__G__Eve1_454_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawCenter",1295,G__G__Eve1_454_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawOrigin",1314,G__G__Eve1_454_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawOrigin",1302,G__G__Eve1_454_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Paint",508,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetListTreeIcon",1493,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TGPicture), -1, 0, 1, 1, 1, 1, "g - 'Bool_t' 0 'kFALSE' open", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_454_0_16, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveProjectionAxes::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_454_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectionAxes::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_454_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveProjectionAxes::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_454_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveProjectionAxes::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_454_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__Eve1_454_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectionAxes::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_454_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjectionAxes::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_454_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectionAxes::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_454_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjectionAxes::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveProjectionAxes", 1952, G__G__Eve1_454_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveProjectionAxesEditor(void) {
   /* TEveProjectionAxesEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesEditor));
   G__memfunc_setup("TEveProjectionAxesEditor",2441,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesEditor), -1, 0, 1, 1, 4, 0, "u 'TEveProjectionAxesEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesEditor), -1, 1, 1, 1, 4, 0, "u 'TEveProjectionAxesEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveProjectionAxesEditor",2441,G__G__Eve1_455_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesEditor), -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("DoLabMode",839,G__G__Eve1_455_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoAxesMode",969,G__G__Eve1_455_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDrawCenter",1186,G__G__Eve1_455_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDrawOrigin",1193,G__G__Eve1_455_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_455_0_9, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveProjectionAxesEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_455_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectionAxesEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_455_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveProjectionAxesEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_455_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveProjectionAxesEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_455_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__Eve1_455_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectionAxesEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_455_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjectionAxesEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_455_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectionAxesEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_455_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjectionAxesEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveProjectionAxesEditor", 2567, G__G__Eve1_455_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveProjectionAxesGL(void) {
   /* TEveProjectionAxesGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesGL));
   G__memfunc_setup("TEveProjectionAxesGL",1973,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesGL), -1, 0, 1, 1, 4, 0, "u 'TEveProjectionAxesGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesGL), -1, 1, 1, 1, 4, 0, "u 'TEveProjectionAxesGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetRange",781,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 4, 8, 
"i - 'Int_t' 0 - ax f - 'Float_t' 0 - frustMin "
"f - 'Float_t' 0 - frustMax f - 'Float_t' 1 - start "
"f - 'Float_t' 1 - en", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SplitInterval",1361,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"f - 'Float_t' 0 - x1 f - 'Float_t' 0 - x2 "
"i - 'Int_t' 0 - axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SplitIntervalByPos",1854,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"f - 'Float_t' 0 - min f - 'Float_t' 0 - max "
"i - 'Int_t' 0 - axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SplitIntervalByVal",1839,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"f - 'Float_t' 0 - min f - 'Float_t' 0 - max "
"i - 'Int_t' 0 - axis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FilterOverlappingLabels",2368,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"i - 'Int_t' 0 - idx f - 'Float_t' 0 - ref", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveProjectionAxesGL",1973,G__G__Eve1_566_0_8, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionAxesGL), -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("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("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("Class",502,G__G__Eve1_566_0_14, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveProjectionAxesGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_566_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectionAxesGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_566_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveProjectionAxesGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_566_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveProjectionAxesGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_566_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__Eve1_566_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectionAxesGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_566_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjectionAxesGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_566_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectionAxesGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_566_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjectionAxesGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveProjectionAxesGL", 2099, G__G__Eve1_566_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveProjectionManagerEditor(void) {
   /* TEveProjectionManagerEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManagerEditor));
   G__memfunc_setup("TEveProjectionManagerEditor",2739,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManagerEditor), -1, 0, 1, 1, 4, 0, "u 'TEveProjectionManagerEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManagerEditor), -1, 1, 1, 1, 4, 0, "u 'TEveProjectionManagerEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveProjectionManagerEditor",2739,G__G__Eve1_571_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectionManagerEditor), -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("DoType",597,G__G__Eve1_571_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDistortion",1250,G__G__Eve1_571_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoFixR",556,G__G__Eve1_571_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoFixZ",564,G__G__Eve1_571_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPastFixRFac",1230,G__G__Eve1_571_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPastFixZFac",1238,G__G__Eve1_571_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCurrentDepth",1419,G__G__Eve1_571_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoMaxTrackStep",1386,G__G__Eve1_571_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCenter",788,G__G__Eve1_571_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_571_0_14, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveProjectionManagerEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_571_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectionManagerEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_571_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveProjectionManagerEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_571_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveProjectionManagerEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_571_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__Eve1_571_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectionManagerEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_571_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjectionManagerEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_571_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjectionManagerEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_571_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjectionManagerEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveProjectionManagerEditor", 2865, G__G__Eve1_571_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveVectorTlEfloatgR(void) {
   /* TEveVectorT<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR));
   G__memfunc_setup("TEveVectorT<float>",1739,G__G__Eve1_573_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVectorT<float>",1739,G__G__Eve1_573_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVectorT<float>",1739,G__G__Eve1_573_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVectorT<float>",1739,G__G__Eve1_573_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 0, 3, 1, 1, 0, 
"f - - 0 - x f - - 0 - y "
"f - - 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Dump",406,G__G__Eve1_573_0_5, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator const float*",2067,G__G__Eve1_573_0_6, 70, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator float*",1484,G__G__Eve1_573_0_7, 70, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Eve1_573_0_8, 102, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Eve1_573_0_9, 102, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Arr",293,G__G__Eve1_573_0_10, 70, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Arr",293,G__G__Eve1_573_0_11, 70, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Eve1_573_0_12, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Eve1_573_0_13, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TEveVectorT<float>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Eve1_573_0_14, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TEveVectorT<float>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Eve1_573_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Eve1_573_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Eve1_573_0_17, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - - 0 - x f - - 0 - y "
"f - - 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Eve1_573_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NegateXYZ",863,G__G__Eve1_573_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Normalize",945,G__G__Eve1_573_0_20, 102, -1, -1, 0, 1, 1, 1, 0, "f - - 0 '1' length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Phi",289,G__G__Eve1_573_0_21, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Theta",502,G__G__Eve1_573_0_22, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CosTheta",795,G__G__Eve1_573_0_23, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eta",282,G__G__Eve1_573_0_24, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mag2",327,G__G__Eve1_573_0_25, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mag",277,G__G__Eve1_573_0_26, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Perp2",457,G__G__Eve1_573_0_27, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Perp",407,G__G__Eve1_573_0_28, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("R",82,G__G__Eve1_573_0_29, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Distance",811,G__G__Eve1_573_0_30, 102, -1, -1, 0, 1, 1, 1, 8, "u 'TEveVectorT<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SquareDistance",1436,G__G__Eve1_573_0_31, 102, -1, -1, 0, 1, 1, 1, 8, "u 'TEveVectorT<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Dot",295,G__G__Eve1_573_0_32, 102, -1, -1, 0, 1, 1, 1, 8, "u 'TEveVectorT<float>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Cross",522,G__G__Eve1_573_0_33, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 0, 1, 1, 1, 8, "u 'TEveVectorT<float>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sub",298,G__G__Eve1_573_0_34, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TEveVectorT<float>' - 11 - a u 'TEveVectorT<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mult",418,G__G__Eve1_573_0_35, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TEveVectorT<float>' - 11 - a f - - 0 - af", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Orthogonal",1053,G__G__Eve1_573_0_36, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OrthoNormBase",1315,G__G__Eve1_573_0_37, 121, -1, -1, 0, 2, 1, 1, 8, 
"u 'TEveVectorT<float>' - 1 - a u 'TEveVectorT<float>' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsZero",604,G__G__Eve1_573_0_38, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_573_0_39, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveVectorT<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_573_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVectorT<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_573_0_41, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveVectorT<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_573_0_42, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveVectorT<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_573_0_43, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_573_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Streamer",835,G__G__Eve1_573_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve1_573_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve1_573_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVectorT<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_573_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveVectorT<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_573_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVectorT<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_573_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveVectorT<float>::DeclFileLine) ), 0);
   G__memfunc_setup("TEveVectorT<float>",1739,G__G__Eve1_573_0_51, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TEveVectorT<double>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TEveVectorT<float>", 1739, G__G__Eve1_573_0_52, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TEveVectorT<float>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveVectorT<float>", 1865, G__G__Eve1_573_0_53, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_573_0_54, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TEveVectorT<float>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveVectorTlEdoublegR(void) {
   /* TEveVectorT<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR));
   G__memfunc_setup("TEveVectorT<double>",1840,G__G__Eve1_574_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVectorT<double>",1840,G__G__Eve1_574_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR), -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVectorT<double>",1840,G__G__Eve1_574_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVectorT<double>",1840,G__G__Eve1_574_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR), -1, 0, 3, 1, 1, 0, 
"d - - 0 - x d - - 0 - y "
"d - - 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Dump",406,G__G__Eve1_574_0_5, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator const double*",2168,G__G__Eve1_574_0_6, 68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator double*",1585,G__G__Eve1_574_0_7, 68, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Eve1_574_0_8, 100, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Eve1_574_0_9, 100, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Arr",293,G__G__Eve1_574_0_10, 68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Arr",293,G__G__Eve1_574_0_11, 68, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Eve1_574_0_12, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Eve1_574_0_13, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TEveVectorT<double>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Eve1_574_0_14, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TEveVectorT<double>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Eve1_574_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Eve1_574_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Eve1_574_0_17, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - - 0 - x d - - 0 - y "
"d - - 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Eve1_574_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVector3' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NegateXYZ",863,G__G__Eve1_574_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Normalize",945,G__G__Eve1_574_0_20, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 '1' length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Phi",289,G__G__Eve1_574_0_21, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Theta",502,G__G__Eve1_574_0_22, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CosTheta",795,G__G__Eve1_574_0_23, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eta",282,G__G__Eve1_574_0_24, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mag2",327,G__G__Eve1_574_0_25, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mag",277,G__G__Eve1_574_0_26, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Perp2",457,G__G__Eve1_574_0_27, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Perp",407,G__G__Eve1_574_0_28, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("R",82,G__G__Eve1_574_0_29, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Distance",811,G__G__Eve1_574_0_30, 100, -1, -1, 0, 1, 1, 1, 8, "u 'TEveVectorT<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SquareDistance",1436,G__G__Eve1_574_0_31, 100, -1, -1, 0, 1, 1, 1, 8, "u 'TEveVectorT<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Dot",295,G__G__Eve1_574_0_32, 100, -1, -1, 0, 1, 1, 1, 8, "u 'TEveVectorT<double>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Cross",522,G__G__Eve1_574_0_33, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR), -1, 0, 1, 1, 1, 8, "u 'TEveVectorT<double>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sub",298,G__G__Eve1_574_0_34, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TEveVectorT<double>' - 11 - a u 'TEveVectorT<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mult",418,G__G__Eve1_574_0_35, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TEveVectorT<double>' - 11 - a d - - 0 - af", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Orthogonal",1053,G__G__Eve1_574_0_36, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OrthoNormBase",1315,G__G__Eve1_574_0_37, 121, -1, -1, 0, 2, 1, 1, 8, 
"u 'TEveVectorT<double>' - 1 - a u 'TEveVectorT<double>' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsZero",604,G__G__Eve1_574_0_38, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_574_0_39, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveVectorT<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_574_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVectorT<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_574_0_41, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveVectorT<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_574_0_42, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveVectorT<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_574_0_43, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_574_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Streamer",835,G__G__Eve1_574_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve1_574_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve1_574_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVectorT<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_574_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveVectorT<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_574_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVectorT<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_574_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveVectorT<double>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEveVectorT<double>", 1840, G__G__Eve1_574_0_51, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TEveVectorT<double>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveVectorT<double>", 1966, G__G__Eve1_574_0_52, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_574_0_53, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TEveVectorT<double>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveVector4TlEfloatgR(void) {
   /* TEveVector4T<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR));
   G__memfunc_setup("TEveVector4T<float>",1791,G__G__Eve1_575_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVector4T<float>",1791,G__G__Eve1_575_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR), -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVector4T<float>",1791,G__G__Eve1_575_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVector4T<float>",1791,G__G__Eve1_575_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR), -1, 0, 4, 1, 1, 0, 
"f - - 0 - x f - - 0 - y "
"f - - 0 - z f - - 0 '0' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Dump",406,G__G__Eve1_575_0_5, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Eve1_575_0_6, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Eve1_575_0_7, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TEveVector4T<float>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Eve1_575_0_8, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TEveVector4T<float>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_575_0_9, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveVector4T<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_575_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVector4T<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_575_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveVector4T<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_575_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveVector4T<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_575_0_13, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_575_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Streamer",835,G__G__Eve1_575_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve1_575_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__Eve1_575_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVector4T<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_575_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveVector4T<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_575_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVector4T<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_575_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveVector4T<float>::DeclFileLine) ), 0);
   G__memfunc_setup("TEveVector4T<float>",1791,G__G__Eve1_575_0_21, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TEveVectorT<double>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVector4T<float>",1791,G__G__Eve1_575_0_22, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TEveVector4T<double>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TEveVector4T<float>", 1791, G__G__Eve1_575_0_23, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TEveVector4T<float>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveVector4T<float>", 1917, G__G__Eve1_575_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_575_0_25, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TEveVector4T<float>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveVector4TlEdoublegR(void) {
   /* TEveVector4T<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR));
   G__memfunc_setup("TEveVector4T<double>",1892,G__G__Eve1_576_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVector4T<double>",1892,G__G__Eve1_576_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR), -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVector4T<double>",1892,G__G__Eve1_576_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVector4T<double>",1892,G__G__Eve1_576_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR), -1, 0, 4, 1, 1, 0, 
"d - - 0 - x d - - 0 - y "
"d - - 0 - z d - - 0 '0' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Dump",406,G__G__Eve1_576_0_5, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Eve1_576_0_6, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Eve1_576_0_7, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TEveVector4T<double>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Eve1_576_0_8, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TEveVector4T<double>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_576_0_9, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveVector4T<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_576_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVector4T<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_576_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveVector4T<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_576_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveVector4T<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_576_0_13, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_576_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Streamer",835,G__G__Eve1_576_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve1_576_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__Eve1_576_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVector4T<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_576_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveVector4T<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_576_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVector4T<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_576_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveVector4T<double>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEveVector4T<double>", 1892, G__G__Eve1_576_0_21, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TEveVector4T<double>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveVector4T<double>", 2018, G__G__Eve1_576_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_576_0_23, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TEveVector4T<double>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveVector2TlEfloatgR(void) {
   /* TEveVector2T<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR));
   G__memfunc_setup("TEveVector2T<float>",1789,G__G__Eve1_577_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVector2T<float>",1789,G__G__Eve1_577_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR), -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVector2T<float>",1789,G__G__Eve1_577_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVector2T<float>",1789,G__G__Eve1_577_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR), -1, 0, 2, 1, 1, 0, 
"f - - 0 - x f - - 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Dump",406,G__G__Eve1_577_0_5, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator const float*",2067,G__G__Eve1_577_0_6, 70, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator float*",1484,G__G__Eve1_577_0_7, 70, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Eve1_577_0_8, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Eve1_577_0_9, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TEveVector2T<float>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Eve1_577_0_10, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TEveVector2T<float>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Eve1_577_0_11, 102, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Eve1_577_0_12, 102, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Arr",293,G__G__Eve1_577_0_13, 70, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Arr",293,G__G__Eve1_577_0_14, 70, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Eve1_577_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Eve1_577_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Eve1_577_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - - 0 - x f - - 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NegateXY",773,G__G__Eve1_577_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Normalize",945,G__G__Eve1_577_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 '1' length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Phi",289,G__G__Eve1_577_0_20, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mag2",327,G__G__Eve1_577_0_21, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mag",277,G__G__Eve1_577_0_22, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Distance",811,G__G__Eve1_577_0_23, 102, -1, -1, 0, 1, 1, 1, 8, "u 'TEveVector2T<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SquareDistance",1436,G__G__Eve1_577_0_24, 102, -1, -1, 0, 1, 1, 1, 8, "u 'TEveVector2T<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Dot",295,G__G__Eve1_577_0_25, 102, -1, -1, 0, 1, 1, 1, 8, "u 'TEveVector2T<float>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Cross",522,G__G__Eve1_577_0_26, 102, -1, -1, 0, 1, 1, 1, 8, "u 'TEveVector2T<float>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sub",298,G__G__Eve1_577_0_27, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TEveVector2T<float>' - 11 - p u 'TEveVector2T<float>' - 11 - q", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mult",418,G__G__Eve1_577_0_28, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TEveVector2T<float>' - 11 - a f - - 0 - af", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_577_0_29, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveVector2T<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_577_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVector2T<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_577_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveVector2T<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_577_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveVector2T<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_577_0_33, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_577_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Streamer",835,G__G__Eve1_577_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve1_577_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__Eve1_577_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVector2T<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_577_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveVector2T<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_577_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVector2T<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_577_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveVector2T<float>::DeclFileLine) ), 0);
   G__memfunc_setup("TEveVector2T<float>",1789,G__G__Eve1_577_0_41, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TEveVector2T<double>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("TEveVector2T<float>", 1789, G__G__Eve1_577_0_42, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TEveVector2T<float>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveVector2T<float>", 1915, G__G__Eve1_577_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_577_0_44, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TEveVector2T<float>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveVector2TlEdoublegR(void) {
   /* TEveVector2T<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR));
   G__memfunc_setup("TEveVector2T<double>",1890,G__G__Eve1_578_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVector2T<double>",1890,G__G__Eve1_578_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR), -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVector2T<double>",1890,G__G__Eve1_578_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveVector2T<double>",1890,G__G__Eve1_578_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR), -1, 0, 2, 1, 1, 0, 
"d - - 0 - x d - - 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Dump",406,G__G__Eve1_578_0_5, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator const double*",2168,G__G__Eve1_578_0_6, 68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator double*",1585,G__G__Eve1_578_0_7, 68, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Eve1_578_0_8, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Eve1_578_0_9, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TEveVector2T<double>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Eve1_578_0_10, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TEveVector2T<double>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Eve1_578_0_11, 100, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Eve1_578_0_12, 100, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Arr",293,G__G__Eve1_578_0_13, 68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Arr",293,G__G__Eve1_578_0_14, 68, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Eve1_578_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Eve1_578_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set",300,G__G__Eve1_578_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - x d - - 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NegateXY",773,G__G__Eve1_578_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Normalize",945,G__G__Eve1_578_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 '1' length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Phi",289,G__G__Eve1_578_0_20, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mag2",327,G__G__Eve1_578_0_21, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mag",277,G__G__Eve1_578_0_22, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Distance",811,G__G__Eve1_578_0_23, 100, -1, -1, 0, 1, 1, 1, 8, "u 'TEveVector2T<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SquareDistance",1436,G__G__Eve1_578_0_24, 100, -1, -1, 0, 1, 1, 1, 8, "u 'TEveVector2T<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Dot",295,G__G__Eve1_578_0_25, 100, -1, -1, 0, 1, 1, 1, 8, "u 'TEveVector2T<double>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Cross",522,G__G__Eve1_578_0_26, 100, -1, -1, 0, 1, 1, 1, 8, "u 'TEveVector2T<double>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sub",298,G__G__Eve1_578_0_27, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TEveVector2T<double>' - 11 - p u 'TEveVector2T<double>' - 11 - q", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mult",418,G__G__Eve1_578_0_28, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TEveVector2T<double>' - 11 - a d - - 0 - af", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_578_0_29, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveVector2T<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_578_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVector2T<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_578_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveVector2T<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_578_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveVector2T<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_578_0_33, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_578_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Streamer",835,G__G__Eve1_578_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve1_578_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__Eve1_578_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVector2T<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_578_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveVector2T<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_578_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVector2T<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_578_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveVector2T<double>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEveVector2T<double>", 1890, G__G__Eve1_578_0_41, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TEveVector2T<double>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveVector2T<double>", 2016, G__G__Eve1_578_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_578_0_43, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TEveVector2T<double>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveProjectioncLcLPreScaleEntry_t(void) {
   /* TEveProjection::PreScaleEntry_t */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t));
   G__memfunc_setup("PreScaleEntry_t",1524,G__G__Eve1_582_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PreScaleEntry_t",1524,G__G__Eve1_582_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t), -1, 0, 4, 1, 1, 0, 
"f - 'Float_t' 0 - min f - 'Float_t' 0 - max "
"f - 'Float_t' 0 - off f - 'Float_t' 0 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_582_0_3, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveProjection::PreScaleEntry_t::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_582_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjection::PreScaleEntry_t::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_582_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveProjection::PreScaleEntry_t::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_582_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveProjection::PreScaleEntry_t::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_582_0_7, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_582_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Eve1_582_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve1_582_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__Eve1_582_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjection::PreScaleEntry_t::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_582_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjection::PreScaleEntry_t::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_582_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveProjection::PreScaleEntry_t::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_582_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveProjection::PreScaleEntry_t::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("PreScaleEntry_t", 1524, G__G__Eve1_582_0_15, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t), -1, 0, 1, 1, 1, 0, "u 'TEveProjection::PreScaleEntry_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~PreScaleEntry_t", 1650, G__G__Eve1_582_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_582_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t), -1, 1, 1, 1, 1, 0, "u 'TEveProjection::PreScaleEntry_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR(void) {
   /* vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> > */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   G__memfunc_setup("at",213,G__G__Eve1_584_0_1, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t), -1, 1, 1, 1, 1, 0, "h - 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("begin",517,G__G__Eve1_584_0_2, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("end",311,G__G__Eve1_584_0_3, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rbegin",631,G__G__Eve1_584_0_4, 117, G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiteratorgR), G__defined_typename("vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("rend",425,G__G__Eve1_584_0_5, 117, G__get_linked_tagnum(&G__G__Eve1LN_reverse_iteratorlEvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiteratorgR), G__defined_typename("vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("size",443,G__G__Eve1_584_0_6, 104, -1, G__defined_typename("vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("max_size",864,G__G__Eve1_584_0_7, 104, -1, G__defined_typename("vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__G__Eve1_584_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("resize",658,G__G__Eve1_584_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type' 0 - sz u 'TEveProjection::PreScaleEntry_t' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("capacity",846,G__G__Eve1_584_0_10, 104, -1, G__defined_typename("vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("empty",559,G__G__Eve1_584_0_11, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Eve1_584_0_12, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t), -1, 1, 1, 1, 1, 0, "h - 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >",8070,G__G__Eve1_584_0_13, 105, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >",8070,G__G__Eve1_584_0_14, 105, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR), -1, 0, 2, 1, 1, 0, 
"h - 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type' 0 - n u 'TEveProjection::PreScaleEntry_t' - 11 'TEveProjection::PreScaleEntry_t()' value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >",8070,G__G__Eve1_584_0_15, 105, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >",8070,G__G__Eve1_584_0_16, 105, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR), -1, 0, 2, 1, 1, 0, 
"u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::const_iterator' 10 - first u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Eve1_584_0_17, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("reserve",764,G__G__Eve1_584_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("front",553,G__G__Eve1_584_0_19, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("back",401,G__G__Eve1_584_0_20, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("push_back",944,G__G__Eve1_584_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEveProjection::PreScaleEntry_t' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("swap",443,G__G__Eve1_584_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Eve1_584_0_23, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
"u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 0 - position u 'TEveProjection::PreScaleEntry_t' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Eve1_584_0_24, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 0 - position u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::const_iterator' 10 - first "
"u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("insert",661,G__G__Eve1_584_0_25, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 0 - position h - 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::size_type' 0 - n "
"u 'TEveProjection::PreScaleEntry_t' - 11 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("pop_back",831,G__G__Eve1_584_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__G__Eve1_584_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("erase",528,G__G__Eve1_584_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 0 - first u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("clear",519,G__G__Eve1_584_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >", 8196, G__G__Eve1_584_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator(void) {
   /* vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator));
   G__memfunc_setup("iterator",874,G__G__Eve1_585_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("iterator",874,G__G__Eve1_585_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator), -1, 0, 1, 5, 1, 0, "U 'TEveProjection::PreScaleEntry_t' 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::pointer' 11 - __i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Eve1_585_0_3, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t), G__defined_typename("vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::reference"), 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator->",983,G__G__Eve1_585_0_4, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t), G__defined_typename("vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::pointer"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Eve1_585_0_5, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator++",962,G__G__Eve1_585_0_6, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Eve1_585_0_7, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator--",966,G__G__Eve1_585_0_8, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "i - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Eve1_585_0_9, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t), G__defined_typename("vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::reference"), 1, 1, 1, 1, 8, "l - 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Eve1_585_0_10, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator), -1, 1, 1, 1, 1, 0, "l - 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__G__Eve1_585_0_11, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 8, "l - 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Eve1_585_0_12, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator), -1, 1, 1, 1, 1, 0, "l - 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__Eve1_585_0_13, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 8, "l - 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::difference_type' 11 - __n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("base",411,G__G__Eve1_585_0_14, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t), G__defined_typename("vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator::pointer"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Eve1_585_0_15, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 11 - x", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("iterator", 874, G__G__Eve1_585_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator), -1, 0, 1, 1, 1, 0, "u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~iterator", 1000, G__G__Eve1_585_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveRhoZProjection(void) {
   /* TEveRhoZProjection */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRhoZProjection));
   G__memfunc_setup("TEveRhoZProjection",1812,G__G__Eve1_587_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveRhoZProjection), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Is2D",306,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Is3D",307,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProjectPoint",1249,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"f - 'Float_t' 1 - x f - 'Float_t' 1 - y "
"f - 'Float_t' 1 - z f - 'Float_t' 0 - d "
"i 'TEveProjection::EPProc_e' - 0 'kPP_Full' proc", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCenter",909,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TEveVectorT<float>' 'TEveVector' 1 - center", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetProjectedCenter",1825,(G__InterfaceMethod) NULL,70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UpdateLimit",1122,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasSeveralSubSpaces",1911,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AcceptSegment",1315,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 8, 
"u 'TEveVectorT<float>' 'TEveVector' 1 - v1 u 'TEveVectorT<float>' 'TEveVector' 1 - v2 "
"f - 'Float_t' 0 - tolerance", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SubSpaceId",963,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "u 'TEveVectorT<float>' 'TEveVector' 11 - v", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsOnSubSpaceBoundrary",2117,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TEveVectorT<float>' 'TEveVector' 11 - v", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDirectionalVector",2061,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - screenAxis u 'TEveVectorT<float>' 'TEveVector' 1 - vec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_587_0_13, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveRhoZProjection::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_587_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRhoZProjection::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_587_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveRhoZProjection::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_587_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveRhoZProjection::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_587_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__Eve1_587_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRhoZProjection::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_587_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRhoZProjection::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_587_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRhoZProjection::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_587_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRhoZProjection::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEveRhoZProjection", 1812, G__G__Eve1_587_0_25, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveRhoZProjection), -1, 0, 1, 1, 1, 0, "u 'TEveRhoZProjection' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveRhoZProjection", 1938, G__G__Eve1_587_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_587_0_27, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveRhoZProjection), -1, 1, 1, 1, 1, 0, "u 'TEveRhoZProjection' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveRPhiProjection(void) {
   /* TEveRPhiProjection */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRPhiProjection));
   G__memfunc_setup("TEveRPhiProjection",1796,G__G__Eve1_588_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveRPhiProjection), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Is2D",306,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Is3D",307,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProjectPoint",1249,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"f - 'Float_t' 1 - x f - 'Float_t' 1 - y "
"f - 'Float_t' 1 - z f - 'Float_t' 0 - d "
"i 'TEveProjection::EPProc_e' - 0 'kPP_Full' proc", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_588_0_5, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveRPhiProjection::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_588_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRPhiProjection::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_588_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveRPhiProjection::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_588_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveRPhiProjection::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_588_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__Eve1_588_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRPhiProjection::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_588_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRPhiProjection::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_588_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRPhiProjection::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_588_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRPhiProjection::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEveRPhiProjection", 1796, G__G__Eve1_588_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveRPhiProjection), -1, 0, 1, 1, 1, 0, "u 'TEveRPhiProjection' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveRPhiProjection", 1922, G__G__Eve1_588_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_588_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveRPhiProjection), -1, 1, 1, 1, 1, 0, "u 'TEveRPhiProjection' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEve3DProjection(void) {
   /* TEve3DProjection */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEve3DProjection));
   G__memfunc_setup("TEve3DProjection",1544,G__G__Eve1_589_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEve3DProjection), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Is2D",306,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Is3D",307,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProjectPoint",1249,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"f - 'Float_t' 1 - x f - 'Float_t' 1 - y "
"f - 'Float_t' 1 - z f - 'Float_t' 0 - d "
"i 'TEveProjection::EPProc_e' - 0 'kPP_Full' proc", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_589_0_5, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEve3DProjection::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_589_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEve3DProjection::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_589_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEve3DProjection::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_589_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEve3DProjection::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_589_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__Eve1_589_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEve3DProjection::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_589_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEve3DProjection::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_589_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEve3DProjection::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_589_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEve3DProjection::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEve3DProjection", 1544, G__G__Eve1_589_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEve3DProjection), -1, 0, 1, 1, 1, 0, "u 'TEve3DProjection' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEve3DProjection", 1670, G__G__Eve1_589_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_589_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEve3DProjection), -1, 1, 1, 1, 1, 0, "u 'TEve3DProjection' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveSceneInfo(void) {
   /* TEveSceneInfo */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneInfo));
   G__memfunc_setup("TEveSceneInfo",1262,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneInfo), -1, 0, 1, 1, 4, 0, "u 'TEveSceneInfo' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneInfo), -1, 1, 1, 1, 4, 0, "u 'TEveSceneInfo' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveSceneInfo",1262,G__G__Eve1_592_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveSceneInfo), -1, 0, 3, 1, 1, 0, 
"U 'TEveViewer' - 0 - viewer U 'TEveScene' - 0 - scene "
"U 'TGLSceneInfo' - 0 - sinfo", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetViewer",914,G__G__Eve1_592_0_4, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveViewer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScene",782,G__G__Eve1_592_0_5, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveScene), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGLSceneInfo",1325,G__G__Eve1_592_0_6, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGLSceneInfo), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGLScene",929,G__G__Eve1_592_0_7, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGLSceneBase), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SingleRnrState",1429,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddStamp",782,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 0 - bits", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AcceptElement",1306,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HandleElementPaste",1811,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_592_0_12, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveSceneInfo::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_592_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveSceneInfo::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_592_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveSceneInfo::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_592_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveSceneInfo::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_592_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__Eve1_592_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveSceneInfo::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_592_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveSceneInfo::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_592_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveSceneInfo::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_592_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveSceneInfo::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveSceneInfo", 1388, G__G__Eve1_592_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTransEditor(void) {
   /* TEveTransEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveTransEditor));
   G__memfunc_setup("TEveTransEditor",1507,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveTransEditor), -1, 0, 1, 1, 4, 0, "u 'TEveTransEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveTransEditor), -1, 1, 1, 1, 4, 0, "u 'TEveTransEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveTransEditor",1507,G__G__Eve1_601_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveTransEditor), -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__Eve1_601_0_5, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTransEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_601_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTransEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_601_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTransEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_601_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTransEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_601_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__Eve1_601_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTransEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_601_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTransEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_601_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTransEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_601_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTransEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTransEditor", 1633, G__G__Eve1_601_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveSelectorToEventList(void) {
   /* TEveSelectorToEventList */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSelectorToEventList));
   G__memfunc_setup("TEveSelectorToEventList",2326,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveSelectorToEventList), -1, 0, 1, 1, 4, 0, "u 'TEveSelectorToEventList' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveSelectorToEventList), -1, 1, 1, 1, 4, 0, "u 'TEveSelectorToEventList' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveSelectorToEventList",2326,G__G__Eve1_648_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveSelectorToEventList), -1, 0, 2, 1, 1, 0, 
"U 'TEventList' - 0 - evl C - - 10 - sel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Version",742,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entry", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_648_0_6, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveSelectorToEventList::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_648_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveSelectorToEventList::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_648_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveSelectorToEventList::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_648_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveSelectorToEventList::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_648_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__Eve1_648_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveSelectorToEventList::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_648_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveSelectorToEventList::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_648_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveSelectorToEventList::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_648_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveSelectorToEventList::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveSelectorToEventList", 2452, G__G__Eve1_648_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvePointSelector(void) {
   /* TEvePointSelector */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelector));
   G__memfunc_setup("TEvePointSelector",1727,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelector), -1, 0, 1, 1, 4, 0, "u 'TEvePointSelector' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelector), -1, 1, 1, 1, 4, 0, "u 'TEvePointSelector' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEvePointSelector",1727,G__G__Eve1_649_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelector), -1, 0, 4, 1, 1, 0, 
"U 'TTree' - 0 '0' t U 'TEvePointSelectorConsumer' - 0 '0' c "
"C - - 10 '\"\"' vexp C - - 10 '\"\"' sel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Select",608,G__G__Eve1_649_0_4, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "C - - 10 '0' selection", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Select",608,G__G__Eve1_649_0_5, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
"U 'TTree' - 0 - t C - - 10 '0' selection", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TakeAction",995,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTree",688,G__G__Eve1_649_0_7, 85, G__get_linked_tagnum(&G__G__Eve1LN_TTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTree",700,G__G__Eve1_649_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTree' - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConsumer",1132,G__G__Eve1_649_0_9, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelectorConsumer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetConsumer",1144,G__G__Eve1_649_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvePointSelectorConsumer' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVarexp",918,G__G__Eve1_649_0_11, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVarexp",930,G__G__Eve1_649_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelection",1222,G__G__Eve1_649_0_13, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSelection",1234,G__G__Eve1_649_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSubIdExp",1060,G__G__Eve1_649_0_15, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSubIdExp",1072,G__G__Eve1_649_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSubIdNum",1063,G__G__Eve1_649_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_649_0_18, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvePointSelector::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_649_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSelector::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_649_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvePointSelector::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_649_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvePointSelector::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_649_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__Eve1_649_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSelector::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_649_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePointSelector::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_649_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSelector::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_649_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePointSelector::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEvePointSelector", 1853, G__G__Eve1_649_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvePointSelectorConsumer(void) {
   /* TEvePointSelectorConsumer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelectorConsumer));
   G__memfunc_setup("InitFill",795,G__G__Eve1_650_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TakeAction",995,G__G__Eve1_650_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvePointSelector' - 0 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetSourceCS",1063,G__G__Eve1_650_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelectorConsumercLcLETreeVarType_e), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSourceCS",1075,G__G__Eve1_650_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TEvePointSelectorConsumer::ETreeVarType_e' - 0 - cs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_650_0_6, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvePointSelectorConsumer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_650_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSelectorConsumer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_650_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvePointSelectorConsumer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_650_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvePointSelectorConsumer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_650_0_10, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_650_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__Eve1_650_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__Eve1_650_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__Eve1_650_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSelectorConsumer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_650_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePointSelectorConsumer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_650_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSelectorConsumer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_650_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePointSelectorConsumer::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEvePointSelectorConsumer", 2697, G__G__Eve1_650_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_650_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEvePointSelectorConsumer), -1, 1, 1, 1, 1, 0, "u 'TEvePointSelectorConsumer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvePathMarkTlEfloatgR(void) {
   /* TEvePathMarkT<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgR));
   G__memfunc_setup("TEvePathMarkT<float>",1904,G__G__Eve1_652_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgR), -1, 0, 1, 1, 1, 0, "i 'TEvePathMarkT<float>::EType_e' - 0 'kReference' type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEvePathMarkT<float>",1904,G__G__Eve1_652_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgR), -1, 0, 3, 1, 1, 0, 
"i 'TEvePathMarkT<float>::EType_e' - 0 - type u 'TEveVectorT<float>' - 11 - v "
"f - - 0 '0' time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEvePathMarkT<float>",1904,G__G__Eve1_652_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgR), -1, 0, 4, 1, 1, 0, 
"i 'TEvePathMarkT<float>::EType_e' - 0 - type u 'TEveVectorT<float>' - 11 - v "
"u 'TEveVectorT<float>' - 11 - p f - - 0 '0' time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEvePathMarkT<float>",1904,G__G__Eve1_652_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgR), -1, 0, 5, 1, 1, 0, 
"i 'TEvePathMarkT<float>::EType_e' - 0 - type u 'TEveVectorT<float>' - 11 - v "
"u 'TEveVectorT<float>' - 11 - p u 'TEveVectorT<float>' - 11 - e "
"f - - 0 '0' time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TypeName",803,G__G__Eve1_652_0_5, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_652_0_6, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvePathMarkT<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_652_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePathMarkT<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_652_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvePathMarkT<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_652_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvePathMarkT<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_652_0_10, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_652_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Streamer",835,G__G__Eve1_652_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve1_652_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__Eve1_652_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePathMarkT<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_652_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePathMarkT<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_652_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePathMarkT<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_652_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePathMarkT<float>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEvePathMarkT<float>", 1904, G__G__Eve1_652_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TEvePathMarkT<float>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEvePathMarkT<float>", 2030, G__G__Eve1_652_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_652_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TEvePathMarkT<float>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvePathMarkTlEdoublegR(void) {
   /* TEvePathMarkT<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegR));
   G__memfunc_setup("TEvePathMarkT<double>",2005,G__G__Eve1_654_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegR), -1, 0, 1, 1, 1, 0, "i 'TEvePathMarkT<double>::EType_e' - 0 'kReference' type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEvePathMarkT<double>",2005,G__G__Eve1_654_0_2, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegR), -1, 0, 3, 1, 1, 0, 
"i 'TEvePathMarkT<double>::EType_e' - 0 - type u 'TEveVectorT<double>' - 11 - v "
"d - - 0 '0' time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEvePathMarkT<double>",2005,G__G__Eve1_654_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegR), -1, 0, 4, 1, 1, 0, 
"i 'TEvePathMarkT<double>::EType_e' - 0 - type u 'TEveVectorT<double>' - 11 - v "
"u 'TEveVectorT<double>' - 11 - p d - - 0 '0' time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEvePathMarkT<double>",2005,G__G__Eve1_654_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegR), -1, 0, 5, 1, 1, 0, 
"i 'TEvePathMarkT<double>::EType_e' - 0 - type u 'TEveVectorT<double>' - 11 - v "
"u 'TEveVectorT<double>' - 11 - p u 'TEveVectorT<double>' - 11 - e "
"d - - 0 '0' time", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TypeName",803,G__G__Eve1_654_0_5, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_654_0_6, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvePathMarkT<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_654_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePathMarkT<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_654_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvePathMarkT<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_654_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvePathMarkT<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_654_0_10, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_654_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Streamer",835,G__G__Eve1_654_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve1_654_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__Eve1_654_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePathMarkT<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_654_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePathMarkT<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_654_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePathMarkT<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_654_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePathMarkT<double>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEvePathMarkT<double>", 2005, G__G__Eve1_654_0_18, (int) ('i'), 
G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TEvePathMarkT<double>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEvePathMarkT<double>", 2131, G__G__Eve1_654_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_654_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEvePathMarkTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TEvePathMarkT<double>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveMCTrack(void) {
   /* TEveMCTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveMCTrack));
   G__memfunc_setup("TEveMCTrack",1017,G__G__Eve1_663_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveMCTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Eve1_663_0_2, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveMCTrack), -1, 1, 1, 1, 1, 0, "u 'TParticle' - 11 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetPdgCode",1177,G__G__Eve1_663_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_663_0_4, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveMCTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_663_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMCTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_663_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveMCTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_663_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveMCTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_663_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__Eve1_663_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMCTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_663_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveMCTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_663_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMCTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_663_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveMCTrack::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEveMCTrack", 1017, G__G__Eve1_663_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveMCTrack), -1, 0, 1, 1, 1, 0, "u 'TEveMCTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveMCTrack", 1143, G__G__Eve1_663_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_663_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveMCTrack), -1, 1, 1, 1, 1, 0, "u 'TEveMCTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveHit(void) {
   /* TEveHit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveHit));
   G__memfunc_setup("TEveHit",665,G__G__Eve1_664_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveHit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_664_0_2, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveHit::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_664_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveHit::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_664_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveHit::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_664_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveHit::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_664_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__Eve1_664_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveHit::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_664_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveHit::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_664_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveHit::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_664_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveHit::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEveHit", 665, G__G__Eve1_664_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveHit), -1, 0, 1, 1, 1, 0, "u 'TEveHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveHit", 791, G__G__Eve1_664_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__Eve1_664_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveHit), -1, 1, 1, 1, 1, 0, "u 'TEveHit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCluster(void) {
   /* TEveCluster */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCluster));
   G__memfunc_setup("TEveCluster",1110,G__G__Eve1_665_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveCluster), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_665_0_2, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCluster::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_665_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCluster::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_665_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCluster::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_665_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCluster::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_665_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__Eve1_665_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCluster::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_665_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCluster::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_665_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCluster::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_665_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCluster::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEveCluster", 1110, G__G__Eve1_665_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveCluster), -1, 0, 1, 1, 1, 0, "u 'TEveCluster' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveCluster", 1236, G__G__Eve1_665_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__Eve1_665_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveCluster), -1, 1, 1, 1, 1, 0, "u 'TEveCluster' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveRecTrack(void) {
   /* TEveRecTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRecTrack));
   G__memfunc_setup("TEveRecTrack",1155,G__G__Eve1_666_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveRecTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Pt",196,G__G__Eve1_666_0_2, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_666_0_3, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveRecTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_666_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRecTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_666_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveRecTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_666_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveRecTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_666_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__Eve1_666_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRecTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_666_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRecTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_666_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRecTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_666_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRecTrack::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEveRecTrack", 1155, G__G__Eve1_666_0_15, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveRecTrack), -1, 0, 1, 1, 1, 0, "u 'TEveRecTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveRecTrack", 1281, G__G__Eve1_666_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Eve1_666_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveRecTrack), -1, 1, 1, 1, 1, 0, "u 'TEveRecTrack' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveRecKink(void) {
   /* TEveRecKink */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRecKink));
   G__memfunc_setup("TEveRecKink",1051,G__G__Eve1_667_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveRecKink), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_667_0_2, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveRecKink::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_667_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRecKink::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_667_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveRecKink::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_667_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveRecKink::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_667_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__Eve1_667_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRecKink::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_667_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRecKink::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_667_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRecKink::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_667_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRecKink::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEveRecKink", 1051, G__G__Eve1_667_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveRecKink), -1, 0, 1, 1, 1, 0, "u 'TEveRecKink' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveRecKink", 1177, G__G__Eve1_667_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__Eve1_667_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveRecKink), -1, 1, 1, 1, 1, 0, "u 'TEveRecKink' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveRecV0(void) {
   /* TEveRecV0 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRecV0));
   G__memfunc_setup("TEveRecV0",788,G__G__Eve1_668_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveRecV0), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_668_0_2, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveRecV0::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_668_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRecV0::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_668_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveRecV0::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_668_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveRecV0::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_668_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__Eve1_668_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRecV0::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_668_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRecV0::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_668_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRecV0::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_668_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRecV0::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEveRecV0", 788, G__G__Eve1_668_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveRecV0), -1, 0, 1, 1, 1, 0, "u 'TEveRecV0' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveRecV0", 914, G__G__Eve1_668_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__Eve1_668_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveRecV0), -1, 1, 1, 1, 1, 0, "u 'TEveRecV0' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveRecCascade(void) {
   /* TEveRecCascade */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveRecCascade));
   G__memfunc_setup("TEveRecCascade",1330,G__G__Eve1_669_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveRecCascade), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_669_0_2, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveRecCascade::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_669_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRecCascade::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_669_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveRecCascade::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_669_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveRecCascade::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_669_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__Eve1_669_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRecCascade::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_669_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRecCascade::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_669_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRecCascade::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_669_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRecCascade::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEveRecCascade", 1330, G__G__Eve1_669_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveRecCascade), -1, 0, 1, 1, 1, 0, "u 'TEveRecCascade' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveRecCascade", 1456, G__G__Eve1_669_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__Eve1_669_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveRecCascade), -1, 1, 1, 1, 1, 0, "u 'TEveRecCascade' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveMCRecCrossRef(void) {
   /* TEveMCRecCrossRef */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveMCRecCrossRef));
   G__memfunc_setup("TEveMCRecCrossRef",1605,G__G__Eve1_670_0_1, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveMCRecCrossRef), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_670_0_2, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveMCRecCrossRef::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_670_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMCRecCrossRef::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_670_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveMCRecCrossRef::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_670_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveMCRecCrossRef::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_670_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__Eve1_670_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMCRecCrossRef::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_670_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveMCRecCrossRef::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_670_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMCRecCrossRef::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_670_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveMCRecCrossRef::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEveMCRecCrossRef", 1605, G__G__Eve1_670_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__Eve1LN_TEveMCRecCrossRef), -1, 0, 1, 1, 1, 0, "u 'TEveMCRecCrossRef' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveMCRecCrossRef", 1731, G__G__Eve1_670_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__Eve1_670_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__Eve1LN_TEveMCRecCrossRef), -1, 1, 1, 1, 1, 0, "u 'TEveMCRecCrossRef' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveVSD(void) {
   /* TEveVSD */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveVSD));
   G__memfunc_setup("TEveVSD",609,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVSD), -1, 0, 1, 1, 4, 0, "u 'TEveVSD' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVSD), -1, 1, 1, 1, 4, 0, "u 'TEveVSD' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveVSD",609,G__G__Eve1_718_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveVSD), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEveVSD\"' name C - - 10 '\"\"' title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDirectory",1249,G__G__Eve1_718_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateTrees",1111,G__G__Eve1_718_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteTrees",1110,G__G__Eve1_718_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateBranches",1402,G__G__Eve1_718_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteTrees",1038,G__G__Eve1_718_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LoadTrees",899,G__G__Eve1_718_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBranchAddresses",1816,G__G__Eve1_718_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DisableTObjectStreamersForVSDStruct",3502,G__G__Eve1_718_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveVSD::DisableTObjectStreamersForVSDStruct) ), 0);
   G__memfunc_setup("Class",502,G__G__Eve1_718_0_12, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveVSD::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_718_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVSD::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_718_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveVSD::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_718_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveVSD::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_718_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__Eve1_718_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVSD::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_718_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveVSD::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_718_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveVSD::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_718_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveVSD::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveVSD", 735, G__G__Eve1_718_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveWindow(void) {
   /* TEveWindow */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow), -1, 1, 1, 1, 4, 0, "u 'TEveWindow' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("SetCurrent",1039,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - curr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreDeleteElement",1604,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NameTitleChanged",1581,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGUIFrame",1008,G__G__Eve1_719_0_7, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGFrame), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PreUndock",907,G__G__Eve1_719_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PostDock",807,G__G__Eve1_719_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CanMakeNewSlots",1487,G__G__Eve1_719_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NewSlot",716,G__G__Eve1_719_0_11, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PopulateEmptyFrame",1860,G__G__Eve1_719_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveCompositeFrame' - 0 - ef", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SwapWindow",1043,G__G__Eve1_719_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveWindow' - 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SwapWindowWithCurrent",2194,G__G__Eve1_719_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("UndockWindow",1244,G__G__Eve1_719_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("UndockWindowDestroySlot",2408,G__G__Eve1_719_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("ReplaceWindow",1332,G__G__Eve1_719_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveWindow' - 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DestroyWindow",1378,G__G__Eve1_719_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("DestroyWindowAndSlot",2071,G__G__Eve1_719_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("GetEveFrame",1067,G__G__Eve1_719_0_20, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrame), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearEveFrame",1266,G__G__Eve1_719_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FlipShowTitleBar",1603,G__G__Eve1_719_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShowTitleBar",1496,G__G__Eve1_719_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShowTitleBar",1508,G__G__Eve1_719_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCurrent",927,G__G__Eve1_719_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeCurrent",1121,G__G__Eve1_719_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsAncestorOf",1200,G__G__Eve1_719_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TEveWindow' - 0 - win", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TitleBarClicked",1478,G__G__Eve1_719_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateDefaultWindowSlot",2355,G__G__Eve1_719_0_29, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TEveWindowSlot* (*)())(&TEveWindow::CreateDefaultWindowSlot) ), 0);
   G__memfunc_setup("CreateWindowMainFrame",2108,G__G__Eve1_719_0_30, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot), -1, 0, 1, 3, 1, 0, "U 'TEveWindow' - 0 '0' eve_parent", (char*)NULL, (void*) G__func2void( (TEveWindowSlot* (*)(TEveWindow*))(&TEveWindow::CreateWindowMainFrame) ), 0);
   G__memfunc_setup("CreateWindowInTab",1690,G__G__Eve1_719_0_31, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot), -1, 0, 2, 3, 1, 0, 
"U 'TGTab' - 0 - tab U 'TEveWindow' - 0 '0' eve_parent", (char*)NULL, (void*) G__func2void( (TEveWindowSlot* (*)(TGTab*, TEveWindow*))(&TEveWindow::CreateWindowInTab) ), 0);
   G__memfunc_setup("SwapWindows",1158,G__G__Eve1_719_0_32, 121, -1, -1, 0, 2, 3, 1, 0, 
"U 'TEveWindow' - 0 - w1 U 'TEveWindow' - 0 - w2", (char*)NULL, (void*) G__func2void( (void (*)(TEveWindow*, TEveWindow*))(&TEveWindow::SwapWindows) ), 0);
   G__memfunc_setup("GetMainFrameDefWidth",1951,G__G__Eve1_719_0_33, 104, -1, G__defined_typename("UInt_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (UInt_t (*)())(&TEveWindow::GetMainFrameDefWidth) ), 0);
   G__memfunc_setup("GetMainFrameDefHeight",2040,G__G__Eve1_719_0_34, 104, -1, G__defined_typename("UInt_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (UInt_t (*)())(&TEveWindow::GetMainFrameDefHeight) ), 0);
   G__memfunc_setup("SetMainFrameDefWidth",1963,G__G__Eve1_719_0_35, 121, -1, -1, 0, 1, 3, 1, 0, "h - 'UInt_t' 0 - x", (char*)NULL, (void*) G__func2void( (void (*)(UInt_t))(&TEveWindow::SetMainFrameDefWidth) ), 0);
   G__memfunc_setup("SetMainFrameDefHeight",2052,G__G__Eve1_719_0_36, 121, -1, -1, 0, 1, 3, 1, 0, "h - 'UInt_t' 0 - x", (char*)NULL, (void*) G__func2void( (void (*)(UInt_t))(&TEveWindow::SetMainFrameDefHeight) ), 0);
   G__memfunc_setup("GetCurrentBackgroundColor",2562,G__G__Eve1_719_0_37, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Pixel_t (*)())(&TEveWindow::GetCurrentBackgroundColor) ), 0);
   G__memfunc_setup("GetMiniBarBackgroundColor",2497,G__G__Eve1_719_0_38, 107, -1, G__defined_typename("Pixel_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Pixel_t (*)())(&TEveWindow::GetMiniBarBackgroundColor) ), 0);
   G__memfunc_setup("SetCurrentBackgroundColor",2574,G__G__Eve1_719_0_39, 121, -1, -1, 0, 1, 3, 1, 0, "k - 'Pixel_t' 0 - p", (char*)NULL, (void*) G__func2void( (void (*)(Pixel_t))(&TEveWindow::SetCurrentBackgroundColor) ), 0);
   G__memfunc_setup("SetMiniBarBackgroundColor",2509,G__G__Eve1_719_0_40, 121, -1, -1, 0, 1, 3, 1, 0, "k - 'Pixel_t' 0 - p", (char*)NULL, (void*) G__func2void( (void (*)(Pixel_t))(&TEveWindow::SetMiniBarBackgroundColor) ), 0);
   G__memfunc_setup("Class",502,G__G__Eve1_719_0_41, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveWindow::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_719_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindow::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_719_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveWindow::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_719_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveWindow::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_719_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__Eve1_719_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindow::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_719_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveWindow::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_719_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindow::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_719_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveWindow::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveWindow", 1130, G__G__Eve1_719_0_53, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveWindowSlot(void) {
   /* TEveWindowSlot */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot));
   G__memfunc_setup("TEveWindowSlot",1422,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot), -1, 0, 1, 1, 4, 0, "u 'TEveWindowSlot' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot), -1, 1, 1, 1, 4, 0, "u 'TEveWindowSlot' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("SetCurrent",1039,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - curr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TEveWindowSlot",1422,G__G__Eve1_720_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEveWindowSlot\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGUIFrame",1008,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TGFrame), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakePack",765,G__G__Eve1_720_0_6, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowPack), -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("MakeTab",661,G__G__Eve1_720_0_7, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowTab), -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("MakeFrame",873,G__G__Eve1_720_0_8, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowFrame), -1, 0, 1, 1, 1, 0, "U 'TGFrame' - 0 '0' frame", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StartEmbedding",1421,G__G__Eve1_720_0_9, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StopEmbedding",1317,G__G__Eve1_720_0_10, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowFrame), -1, 0, 1, 1, 1, 0, "C - - 10 '0' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_720_0_11, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveWindowSlot::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_720_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowSlot::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_720_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveWindowSlot::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_720_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveWindowSlot::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_720_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__Eve1_720_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowSlot::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_720_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveWindowSlot::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_720_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowSlot::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_720_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveWindowSlot::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveWindowSlot", 1548, G__G__Eve1_720_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveWindowFrame(void) {
   /* TEveWindowFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowFrame));
   G__memfunc_setup("TEveWindowFrame",1495,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowFrame), -1, 0, 1, 1, 4, 0, "u 'TEveWindowFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowFrame), -1, 1, 1, 1, 4, 0, "u 'TEveWindowFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveWindowFrame",1495,G__G__Eve1_721_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowFrame), -1, 0, 3, 1, 1, 0, 
"U 'TGFrame' - 0 - frame C - - 10 '\"TEveWindowFrame\"' n "
"C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGUIFrame",1008,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TGFrame), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGUICompositeFrame",1955,G__G__Eve1_721_0_5, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGCompositeFrame), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_721_0_6, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveWindowFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_721_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_721_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveWindowFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_721_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveWindowFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_721_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__Eve1_721_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_721_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveWindowFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_721_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_721_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveWindowFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveWindowFrame", 1621, G__G__Eve1_721_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveWindowPack(void) {
   /* TEveWindowPack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowPack));
   G__memfunc_setup("TEveWindowPack",1387,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowPack), -1, 0, 1, 1, 4, 0, "u 'TEveWindowPack' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowPack), -1, 1, 1, 1, 4, 0, "u 'TEveWindowPack' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveWindowPack",1387,G__G__Eve1_723_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowPack), -1, 0, 3, 1, 1, 0, 
"U 'TGPack' - 0 - p C - - 10 '\"TEveWindowPack\"' n "
"C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGUIFrame",1008,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TGFrame), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CanMakeNewSlots",1487,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NewSlotWithWeight",1744,G__G__Eve1_723_0_6, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot), -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NewSlot",716,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot), -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("FlipOrientation",1559,G__G__Eve1_723_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetVertical",1126,G__G__Eve1_723_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHorizontal",1366,G__G__Eve1_723_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EqualizeFrames",1438,G__G__Eve1_723_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("GetPack",671,G__G__Eve1_723_0_12, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGPack), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_723_0_13, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveWindowPack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_723_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowPack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_723_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveWindowPack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_723_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveWindowPack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_723_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__Eve1_723_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowPack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_723_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveWindowPack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_723_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowPack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_723_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveWindowPack::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveWindowPack", 1513, G__G__Eve1_723_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveWindowTab(void) {
   /* TEveWindowTab */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowTab));
   G__memfunc_setup("TEveWindowTab",1283,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowTab), -1, 0, 1, 1, 4, 0, "u 'TEveWindowTab' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowTab), -1, 1, 1, 1, 4, 0, "u 'TEveWindowTab' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveWindowTab",1283,G__G__Eve1_724_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowTab), -1, 0, 3, 1, 1, 0, 
"U 'TGTab' - 0 - tab C - - 10 '\"TEveWindowTab\"' n "
"C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGUIFrame",1008,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TGFrame), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CanMakeNewSlots",1487,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NewSlot",716,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowSlot), -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("GetTab",567,G__G__Eve1_724_0_7, 85, G__get_linked_tagnum(&G__G__Eve1LN_TGTab), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_724_0_8, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveWindowTab::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_724_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowTab::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_724_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveWindowTab::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_724_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveWindowTab::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_724_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__Eve1_724_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowTab::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_724_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveWindowTab::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_724_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowTab::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_724_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveWindowTab::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveWindowTab", 1409, G__G__Eve1_724_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCompositeFrame(void) {
   /* TEveCompositeFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrame));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrame), -1, 1, 1, 1, 4, 0, "u 'TEveCompositeFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("WindowNameChanged",1699,G__G__Eve1_726_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Destroy",746,G__G__Eve1_726_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AcquireEveWindow",1634,G__G__Eve1_726_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveWindow' - 0 - ew", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RelinquishEveWindow",1980,G__G__Eve1_726_0_7, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' reparent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEveWindow",1208,G__G__Eve1_726_0_8, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEveParentAsWindow",2006,G__G__Eve1_726_0_9, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrent",1039,G__G__Eve1_726_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - curr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetShowTitleBar",1508,G__G__Eve1_726_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - show", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HideAllDecorations",1806,G__G__Eve1_726_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowNormalDecorations",2181,G__G__Eve1_726_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ActionPressed",1332,G__G__Eve1_726_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FlipTitleBarState",1699,G__G__Eve1_726_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TitleBarClicked",1478,G__G__Eve1_726_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetupFrameMarkup",1644,G__G__Eve1_726_0_17, 121, -1, -1, 0, 4, 3, 1, 0, 
"Y - 'TEveCompositeFrame::IconBarCreator_foo' 0 - creator h - 'UInt_t' 0 '14' top_frame_height "
"h - 'UInt_t' 0 '4' mini_bar_height g - 'Bool_t' 0 'kTRUE' allow_top_collapse", (char*)NULL, (void*) G__func2void( (void (*)(TEveCompositeFrame::IconBarCreator_foo, UInt_t, UInt_t, Bool_t))(&TEveCompositeFrame::SetupFrameMarkup) ), 0);
   G__memfunc_setup("Class",502,G__G__Eve1_726_0_18, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCompositeFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_726_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompositeFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_726_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCompositeFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_726_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCompositeFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_726_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__Eve1_726_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompositeFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_726_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCompositeFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_726_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompositeFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_726_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCompositeFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCompositeFrame", 1936, G__G__Eve1_726_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCompositeFrameInMainFrame(void) {
   /* TEveCompositeFrameInMainFrame */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInMainFrame));
   G__memfunc_setup("TEveCompositeFrameInMainFrame",2873,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInMainFrame), -1, 0, 1, 1, 4, 0, "u 'TEveCompositeFrameInMainFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInMainFrame), -1, 1, 1, 1, 4, 0, "u 'TEveCompositeFrameInMainFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveCompositeFrameInMainFrame",2873,G__G__Eve1_727_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInMainFrame), -1, 0, 3, 1, 1, 0, 
"U 'TGCompositeFrame' - 0 - parent U 'TEveWindow' - 0 - eve_parent "
"U 'TGMainFrame' - 0 - mf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WindowNameChanged",1699,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Destroy",746,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOriginalSlotAndContainer",2745,G__G__Eve1_727_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveWindow' - 0 - slot U 'TEveWindow' - 0 - container", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SomeWindowClosed",1638,G__G__Eve1_727_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveWindow' - 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MainFrameClosed",1482,G__G__Eve1_727_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOriginalSlot",1527,G__G__Eve1_727_0_9, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOriginalContainer",2040,G__G__Eve1_727_0_10, 85, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindow), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_727_0_11, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCompositeFrameInMainFrame::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_727_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompositeFrameInMainFrame::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_727_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCompositeFrameInMainFrame::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_727_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCompositeFrameInMainFrame::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_727_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__Eve1_727_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompositeFrameInMainFrame::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_727_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCompositeFrameInMainFrame::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_727_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompositeFrameInMainFrame::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_727_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCompositeFrameInMainFrame::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCompositeFrameInMainFrame", 2999, G__G__Eve1_727_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCompositeFrameInPack(void) {
   /* TEveCompositeFrameInPack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInPack));
   G__memfunc_setup("TEveCompositeFrameInPack",2376,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInPack), -1, 0, 1, 1, 4, 0, "u 'TEveCompositeFrameInPack' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInPack), -1, 1, 1, 1, 4, 0, "u 'TEveCompositeFrameInPack' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveCompositeFrameInPack",2376,G__G__Eve1_728_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInPack), -1, 0, 3, 1, 1, 0, 
"U 'TGCompositeFrame' - 0 - parent U 'TEveWindow' - 0 - eve_parent "
"U 'TGPack' - 0 - pack", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Destroy",746,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_728_0_5, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCompositeFrameInPack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_728_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompositeFrameInPack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_728_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCompositeFrameInPack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_728_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCompositeFrameInPack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_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__Eve1_728_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompositeFrameInPack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_728_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCompositeFrameInPack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_728_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompositeFrameInPack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_728_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCompositeFrameInPack::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCompositeFrameInPack", 2502, G__G__Eve1_728_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCompositeFrameInTab(void) {
   /* TEveCompositeFrameInTab */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInTab));
   G__memfunc_setup("TEveCompositeFrameInTab",2272,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInTab), -1, 0, 1, 1, 4, 0, "u 'TEveCompositeFrameInTab' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInTab), -1, 1, 1, 1, 4, 0, "u 'TEveCompositeFrameInTab' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("FindTabIndex",1168,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveCompositeFrameInTab",2272,G__G__Eve1_729_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveCompositeFrameInTab), -1, 0, 3, 1, 1, 0, 
"U 'TGCompositeFrame' - 0 - parent U 'TEveWindow' - 0 - eve_parent "
"U 'TGTab' - 0 - tab", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WindowNameChanged",1699,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Destroy",746,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCurrent",1039,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - curr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve1_729_0_8, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCompositeFrameInTab::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_729_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompositeFrameInTab::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_729_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCompositeFrameInTab::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_729_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCompositeFrameInTab::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_729_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__Eve1_729_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompositeFrameInTab::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_729_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCompositeFrameInTab::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_729_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCompositeFrameInTab::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_729_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCompositeFrameInTab::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCompositeFrameInTab", 2398, G__G__Eve1_729_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveViewerListEditor(void) {
   /* TEveViewerListEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerListEditor));
   G__memfunc_setup("TEveViewerListEditor",2025,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerListEditor), -1, 0, 1, 1, 4, 0, "u 'TEveViewerListEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerListEditor), -1, 1, 1, 1, 4, 0, "u 'TEveViewerListEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveViewerListEditor",2025,G__G__Eve1_732_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveViewerListEditor), -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("DoBrightness",1228,G__G__Eve1_732_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SwitchColorSet",1437,G__G__Eve1_732_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_732_0_7, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveViewerListEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_732_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveViewerListEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_732_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveViewerListEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_732_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveViewerListEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_732_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__Eve1_732_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveViewerListEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_732_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveViewerListEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_732_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveViewerListEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_732_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveViewerListEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveViewerListEditor", 2151, G__G__Eve1_732_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveWindowEditor(void) {
   /* TEveWindowEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowEditor));
   G__memfunc_setup("TEveWindowEditor",1619,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowEditor), -1, 0, 1, 1, 4, 0, "u 'TEveWindowEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowEditor), -1, 1, 1, 1, 4, 0, "u 'TEveWindowEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveWindowEditor",1619,G__G__Eve1_733_0_3, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveWindowEditor), -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("DoShowTitleBar",1387,G__G__Eve1_733_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_733_0_6, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveWindowEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_733_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_733_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveWindowEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_733_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveWindowEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve1LN_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__Eve1_733_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__Eve1_733_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_733_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveWindowEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_733_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveWindowEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_733_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveWindowEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveWindowEditor", 1745, G__G__Eve1_733_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveSecondarySelectable(void) {
   /* TEveSecondarySelectable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve1LN_TEveSecondarySelectable));
   G__memfunc_setup("TEveSecondarySelectable",2320,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveSecondarySelectable), -1, 0, 1, 1, 4, 0, "u 'TEveSecondarySelectable' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveSecondarySelectable), -1, 1, 1, 1, 4, 0, "u 'TEveSecondarySelectable' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("ProcessGLSelectionInternal",2645,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"u 'TGLSelectRecord' - 1 - rec u 'set<int,less<int>,allocator<int> >' 'TEveSecondarySelectable::SelectionSet_t' 1 - sset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveSecondarySelectable",2320,G__G__Eve1_734_0_4, 105, G__get_linked_tagnum(&G__G__Eve1LN_TEveSecondarySelectable), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAlwaysSecSelect",1804,G__G__Eve1_734_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAlwaysSecSelect",1816,G__G__Eve1_734_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefSelectedSet",1394,G__G__Eve1_734_0_7, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR), G__defined_typename("TEveSecondarySelectable::SelectionSet_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefHighlightedSet",1706,G__G__Eve1_734_0_8, 117, G__get_linked_tagnum(&G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR), G__defined_typename("TEveSecondarySelectable::SelectionSet_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessGLSelection",1816,G__G__Eve1_734_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLSelectRecord' - 1 - rec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve1_734_0_10, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveSecondarySelectable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve1_734_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveSecondarySelectable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve1_734_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveSecondarySelectable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve1_734_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveSecondarySelectable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve1_734_0_14, 85, G__get_linked_tagnum(&G__G__Eve1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve1_734_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__Eve1_734_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__Eve1_734_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__Eve1_734_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveSecondarySelectable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve1_734_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveSecondarySelectable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve1_734_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveSecondarySelectable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve1_734_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveSecondarySelectable::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveSecondarySelectable", 2446, G__G__Eve1_734_0_22, (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__Eve1() {
}

/*********************************************************
* 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() {
   G__memvar_setup((void*)(&gEve),85,0,0,G__get_linked_tagnum(&G__G__Eve1LN_TEveManager),-1,-1,1,"gEve=",0,(char*)NULL);
}

static void G__cpp_setup_global7() {
}

static void G__cpp_setup_global8() {
}

static void G__cpp_setup_global9() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Eve1() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
  G__cpp_setup_global4();
  G__cpp_setup_global5();
  G__cpp_setup_global6();
  G__cpp_setup_global7();
  G__cpp_setup_global8();
  G__cpp_setup_global9();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

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() {
   G__memfunc_setup("operator==", 998, G__G__Eve1__0_1565, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 11 - x u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Eve1__0_1566, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 11 - x u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Eve1__0_1567, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 11 - x u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Eve1__0_1568, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 11 - x u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Eve1__0_1569, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 11 - x u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Eve1__0_1570, 103, -1, -1, 0, 2, 1, 1, 8, 
"u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 11 - x u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Eve1__0_1571, 108, -1, G__defined_typename("difference_type"), 0, 2, 1, 1, 8, 
"u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 11 - x u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Eve1__0_1572, 117, G__get_linked_tagnum(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 8, 
"l - 'difference_type' 10 - x u 'vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator' - 11 - y", (char*) NULL
, (void*) NULL, 0);
}

static void G__cpp_setup_func16() {
   G__memfunc_setup("operator+", 919, G__G__Eve1__0_1678, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVectorT<float>' - 11 - a u 'TEveVectorT<float>' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Eve1__0_1679, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVectorT<float>' - 11 - a u 'TEveVectorT<float>' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Eve1__0_1680, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVectorT<float>' - 11 - a f - - 0 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Eve1__0_1681, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"f - - 0 - b u 'TEveVectorT<float>' - 11 - a", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Eve1__0_1682, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVector4T<float>' - 11 - a u 'TEveVector4T<float>' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Eve1__0_1683, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVector4T<float>' - 11 - a u 'TEveVector4T<float>' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Eve1__0_1684, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVector4T<float>' - 11 - a f - - 0 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Eve1__0_1685, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEfloatgR), -1, 0, 2, 1, 1, 0, 
"f - - 0 - b u 'TEveVector4T<float>' - 11 - a", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Eve1__0_1686, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVector2T<float>' - 11 - a u 'TEveVector2T<float>' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Eve1__0_1687, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVector2T<float>' - 11 - a u 'TEveVector2T<float>' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Eve1__0_1688, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVector2T<float>' - 11 - a f - - 0 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Eve1__0_1689, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEfloatgR), -1, 0, 2, 1, 1, 0, 
"f - - 0 - b u 'TEveVector2T<float>' - 11 - a", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Eve1__0_1690, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVectorT<double>' - 11 - a u 'TEveVectorT<double>' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Eve1__0_1691, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVectorT<double>' - 11 - a u 'TEveVectorT<double>' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Eve1__0_1692, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVectorT<double>' - 11 - a d - - 0 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Eve1__0_1693, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVectorTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"d - - 0 - b u 'TEveVectorT<double>' - 11 - a", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Eve1__0_1694, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVector4T<double>' - 11 - a u 'TEveVector4T<double>' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Eve1__0_1695, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVector4T<double>' - 11 - a u 'TEveVector4T<double>' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Eve1__0_1696, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVector4T<double>' - 11 - a d - - 0 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Eve1__0_1697, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector4TlEdoublegR), -1, 0, 2, 1, 1, 0, 
"d - - 0 - b u 'TEveVector4T<double>' - 11 - a", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Eve1__0_1698, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVector2T<double>' - 11 - a u 'TEveVector2T<double>' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Eve1__0_1699, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVector2T<double>' - 11 - a u 'TEveVector2T<double>' - 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Eve1__0_1700, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TEveVector2T<double>' - 11 - a d - - 0 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Eve1__0_1701, 117, G__get_linked_tagnum(&G__G__Eve1LN_TEveVector2TlEdoublegR), -1, 0, 2, 1, 1, 0, 
"d - - 0 - b u 'TEveVector2T<double>' - 11 - a", (char*) NULL
, (void*) NULL, 0);

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Eve1() {
  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();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__Eve1LN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TDirectory = { "TDirectory" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_string = { "string" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TTimer = { "TTimer" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TPRegexp = { "TPRegexp" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_Event_t = { "Event_t" , 115 , -1 };
G__linked_taginfo G__G__Eve1LN_exception = { "exception" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TVirtualPad = { "TVirtualPad" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGeoManager = { "TGeoManager" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveElement = { "TEveElement" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveUtil = { "TEveUtil" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveException = { "TEveException" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEvePadHolder = { "TEvePadHolder" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveGeoManagerHolder = { "TEveGeoManagerHolder" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveRefCnt = { "TEveRefCnt" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveRefBackPtr = { "TEveRefBackPtr" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_lesslETEveElementmUgR = { "less<TEveElement*>" , 115 , -1 };
G__linked_taginfo G__G__Eve1LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgR = { "map<TEveElement*,int,less<TEveElement*>,allocator<pair<TEveElement* const,int> > >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgRcLcLiterator = { "map<TEveElement*,int,less<TEveElement*>,allocator<pair<TEveElement* const,int> > >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveProjection = { "TEveProjection" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveProjected = { "TEveProjected" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveProjectionManager = { "TEveProjectionManager" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveProjectable = { "TEveProjectable" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_listlETEveProjectedmUcOallocatorlETEveProjectedmUgRsPgR = { "list<TEveProjected*,allocator<TEveProjected*> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_listlETEveProjectedmUcOallocatorlETEveProjectedmUgRsPgRcLcLiterator = { "list<TEveProjected*,allocator<TEveProjected*> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_allocatorlETEveElementmUgR = { "allocator<TEveElement*>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR = { "set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator = { "set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLreverse_iterator = { "set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::reverse_iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_pairlEsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiteratorcOboolgR = { "pair<set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator,bool>" , 115 , -1 };
G__linked_taginfo G__G__Eve1LN_TFile = { "TFile" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TRef = { "TRef" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGListTree = { "TGListTree" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGListTreeItem = { "TGListTreeItem" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGPicture = { "TGPicture" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveCompound = { "TEveCompound" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveTrans = { "TEveTrans" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGeoMatrix = { "TGeoMatrix" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveManager = { "TEveManager" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveElementcLcLTEveListTreeInfo = { "TEveElement::TEveListTreeInfo" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgR = { "set<TEveElement::TEveListTreeInfo,less<TEveElement::TEveListTreeInfo>,allocator<TEveElement::TEveListTreeInfo> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgRcLcLiterator = { "set<TEveElement::TEveListTreeInfo,less<TEveElement::TEveListTreeInfo>,allocator<TEveElement::TEveListTreeInfo> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgRcLcLreverse_iterator = { "set<TEveElement::TEveListTreeInfo,less<TEveElement::TEveListTreeInfo>,allocator<TEveElement::TEveListTreeInfo> >::reverse_iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR = { "list<TEveElement*,allocator<TEveElement*> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator = { "list<TEveElement*,allocator<TEveElement*> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLreverse_iterator = { "list<TEveElement*,allocator<TEveElement*> >::reverse_iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveElementcLcLECompoundSelectionColorBits = { "TEveElement::ECompoundSelectionColorBits" , 101 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveElementcLcLEDestruct = { "TEveElement::EDestruct" , 101 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveElementcLcLEChangeBits = { "TEveElement::EChangeBits" , 101 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveElementObjectPtr = { "TEveElementObjectPtr" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveElementList = { "TEveElementList" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveElementListProjected = { "TEveElementListProjected" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGObject = { "TGObject" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TQObject = { "TQObject" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGWindow = { "TGWindow" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TAttLine = { "TAttLine" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TAttFill = { "TAttFill" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGFrame = { "TGFrame" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGCompositeFrame = { "TGCompositeFrame" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGLayoutHints = { "TGLayoutHints" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__Eve1LN_TGTextButton = { "TGTextButton" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGVerticalFrame = { "TGVerticalFrame" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGHorizontalFrame = { "TGHorizontalFrame" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGMainFrame = { "TGMainFrame" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TBrowserImp = { "TBrowserImp" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGTab = { "TGTab" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGMenuBar = { "TGMenuBar" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGPopupMenu = { "TGPopupMenu" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGStatusBar = { "TGStatusBar" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TRootBrowser = { "TRootBrowser" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGCanvas = { "TGCanvas" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGWidget = { "TGWidget" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TContextMenu = { "TContextMenu" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGFileBrowser = { "TGFileBrowser" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGSplitter = { "TGSplitter" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveGedEditor = { "TEveGedEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveListTreeItem = { "TEveListTreeItem" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveGListTreeEditorFrame = { "TEveGListTreeEditorFrame" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveBrowser = { "TEveBrowser" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveChunkManager = { "TEveChunkManager" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlETArrayCmUcOallocatorlETArrayCmUgRsPgR = { "vector<TArrayC*,allocator<TArrayC*> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_reverse_iteratorlEvectorlETArrayCmUcOallocatorlETArrayCmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TArrayC*,allocator<TArrayC*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveChunkManagercLcLiterator = { "TEveChunkManager::iterator" , 115 , -1 };
G__linked_taginfo G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR = { "set<int,less<int>,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgRcLcLiterator = { "set<int,less<int>,allocator<int> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveCompoundProjected = { "TEveCompoundProjected" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TCanvas = { "TCanvas" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGLabel = { "TGLabel" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGedEditor = { "TGedEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGedFrame = { "TGedFrame" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGCheckButton = { "TGCheckButton" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGNumberEntry = { "TGNumberEntry" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGColorSelect = { "TGColorSelect" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveTransSubEditor = { "TEveTransSubEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveElementEditor = { "TEveElementEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveEventManager = { "TEveEventManager" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGButton = { "TGButton" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGNumberFormat = { "TGNumberFormat" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGNumberFormatcLcLEStyle = { "TGNumberFormat::EStyle" , 101 , -1 };
G__linked_taginfo G__G__Eve1LN_TGHSlider = { "TGHSlider" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGDoubleHSlider = { "TGDoubleHSlider" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveGValuatorBase = { "TEveGValuatorBase" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveGValuator = { "TEveGValuator" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveGDoubleValuator = { "TEveGDoubleValuator" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveGTriVecValuator = { "TEveGTriVecValuator" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TVirtualPadEditor = { "TVirtualPadEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMap = { "TMap" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveGedNameFrame = { "TEveGedNameFrame" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveGedNameTextButton = { "TEveGedNameTextButton" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMacro = { "TMacro" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveMacro = { "TEveMacro" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TSysEvtHandler = { "TSysEvtHandler" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TStdExceptionHandler = { "TStdExceptionHandler" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TStdExceptionHandlercLcLEStatus = { "TStdExceptionHandler::EStatus" , 101 , -1 };
G__linked_taginfo G__G__Eve1LN_TAttPad = { "TAttPad" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TVirtualViewer3D = { "TVirtualViewer3D" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TExMap = { "TExMap" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TFolder = { "TFolder" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGLViewer = { "TGLViewer" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveSelection = { "TEveSelection" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveViewer = { "TEveViewer" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveViewerList = { "TEveViewerList" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveScene = { "TEveScene" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveSceneList = { "TEveSceneList" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveWindowManager = { "TEveWindowManager" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveManagercLcLTRedrawDisabler = { "TEveManager::TRedrawDisabler" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveManagercLcLTExceptionHandler = { "TEveManager::TExceptionHandler" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TPad = { "TPad" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEvePad = { "TEvePad" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveParamList = { "TEveParamList" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveParamListEditor = { "TEveParamListEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveParamListcLcLFloatConfig_t = { "TEveParamList::FloatConfig_t" , 115 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgR = { "vector<TEveParamList::FloatConfig_t,allocator<TEveParamList::FloatConfig_t> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgRcLcLiterator = { "vector<TEveParamList::FloatConfig_t,allocator<TEveParamList::FloatConfig_t> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_reverse_iteratorlEvectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TEveParamList::FloatConfig_t,allocator<TEveParamList::FloatConfig_t> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveParamListcLcLIntConfig_t = { "TEveParamList::IntConfig_t" , 115 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgR = { "vector<TEveParamList::IntConfig_t,allocator<TEveParamList::IntConfig_t> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgRcLcLiterator = { "vector<TEveParamList::IntConfig_t,allocator<TEveParamList::IntConfig_t> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_reverse_iteratorlEvectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TEveParamList::IntConfig_t,allocator<TEveParamList::IntConfig_t> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveParamListcLcLBoolConfig_t = { "TEveParamList::BoolConfig_t" , 115 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgR = { "vector<TEveParamList::BoolConfig_t,allocator<TEveParamList::BoolConfig_t> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgRcLcLiterator = { "vector<TEveParamList::BoolConfig_t,allocator<TEveParamList::BoolConfig_t> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_reverse_iteratorlEvectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TEveParamList::BoolConfig_t,allocator<TEveParamList::BoolConfig_t> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlETGNumberEntrymUcOallocatorlETGNumberEntrymUgRsPgR = { "vector<TGNumberEntry*,allocator<TGNumberEntry*> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_reverse_iteratorlEvectorlETGNumberEntrymUcOallocatorlETGNumberEntrymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TGNumberEntry*,allocator<TGNumberEntry*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlETGCheckButtonmUcOallocatorlETGCheckButtonmUgRsPgR = { "vector<TGCheckButton*,allocator<TGCheckButton*> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_reverse_iteratorlEvectorlETGCheckButtonmUcOallocatorlETGCheckButtonmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TGCheckButton*,allocator<TGCheckButton*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGComboBox = { "TGComboBox" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveProjectionAxes = { "TEveProjectionAxes" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveProjectionAxesEditor = { "TEveProjectionAxesEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR = { "vector<TGLPlane,allocator<TGLPlane> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_reverse_iteratorlEvectorlETGLPlanecOallocatorlETGLPlanegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TGLPlane,allocator<TGLPlane> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_pairlEboolcOTGLLine3gR = { "pair<bool,TGLLine3>" , 115 , -1 };
G__linked_taginfo G__G__Eve1LN_pairlEboolcOTGLVertex3gR = { "pair<bool,TGLVertex3>" , 115 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR = { "vector<unsigned char,allocator<unsigned char> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_reverse_iteratorlEvectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned char,allocator<unsigned char> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_pairlEintcOintgR = { "pair<int,int>" , 115 , -1 };
G__linked_taginfo G__G__Eve1LN_pairlEdoublecOdoublegR = { "pair<double,double>" , 115 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<double,allocator<double> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TBuffer3D = { "TBuffer3D" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGLRnrCtx = { "TGLRnrCtx" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGLSelectRecord = { "TGLSelectRecord" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGLSceneBase = { "TGLSceneBase" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGLLogicalShape = { "TGLLogicalShape" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGLObject = { "TGLObject" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR = { "map<TGLFont,int,less<TGLFont>,allocator<pair<const TGLFont,int> > >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgR = { "list<const TGLFont*,allocator<const TGLFont*> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TAttAxis = { "TAttAxis" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGLAxisPainter = { "TGLAxisPainter" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_pairlEfloatcOfloatgR = { "pair<float,float>" , 115 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR = { "vector<pair<float,float>,allocator<pair<float,float> > >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<float,float>,allocator<pair<float,float> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_pairlEfloatcOintgR = { "pair<float,int>" , 115 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR = { "vector<pair<float,int>,allocator<pair<float,int> > >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_reverse_iteratorlEvectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<float,int>,allocator<pair<float,int> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveProjectionAxesGL = { "TEveProjectionAxesGL" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TAtt3D = { "TAtt3D" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TAttBBox = { "TAttBBox" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveProjectionAxescLcLELabMode = { "TEveProjectionAxes::ELabMode" , 101 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveProjectionAxescLcLEAxesMode = { "TEveProjectionAxes::EAxesMode" , 101 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveProjectionManagerEditor = { "TEveProjectionManagerEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TVector3 = { "TVector3" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveVectorTlEfloatgR = { "TEveVectorT<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveVectorTlEdoublegR = { "TEveVectorT<double>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveVector4TlEfloatgR = { "TEveVector4T<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveVector4TlEdoublegR = { "TEveVector4T<double>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveVector2TlEfloatgR = { "TEveVector2T<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveVector2TlEdoublegR = { "TEveVector2T<double>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveProjectioncLcLEPType_e = { "TEveProjection::EPType_e" , 101 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveProjectioncLcLEPProc_e = { "TEveProjection::EPProc_e" , 101 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveProjectioncLcLEGeoMode_e = { "TEveProjection::EGeoMode_e" , 101 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t = { "TEveProjection::PreScaleEntry_t" , 115 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR = { "vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator = { "vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_reverse_iteratorlEvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveRhoZProjection = { "TEveRhoZProjection" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveRPhiProjection = { "TEveRPhiProjection" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEve3DProjection = { "TEve3DProjection" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGLScenePad = { "TGLScenePad" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGLSceneInfo = { "TGLSceneInfo" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveSceneInfo = { "TEveSceneInfo" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveSelectioncLcLEPickToSelect = { "TEveSelection::EPickToSelect" , 101 , -1 };
G__linked_taginfo G__G__Eve1LN_maplETEveElementmUcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRsPgRsPgRsPgR = { "map<TEveElement*,set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >,less<TEveElement*>,allocator<pair<TEveElement* const,set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> > > > >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_maplETEveElementmUcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRsPgRsPgRsPgRcLcLiterator = { "map<TEveElement*,set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >,less<TEveElement*>,allocator<pair<TEveElement* const,set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> > > > >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveTransEditor = { "TEveTransEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TElementActionTlEfloatgR = { "TElementActionT<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TElementPosActionTlEfloatgR = { "TElementPosActionT<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMatrixTlEfloatgR = { "TMatrixT<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMatrixTRow_constlEfloatgR = { "TMatrixTRow_const<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMatrixTRowlEfloatgR = { "TMatrixTRow<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMatrixTDiag_constlEfloatgR = { "TMatrixTDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMatrixTColumn_constlEfloatgR = { "TMatrixTColumn_const<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMatrixTFlat_constlEfloatgR = { "TMatrixTFlat_const<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMatrixTSub_constlEfloatgR = { "TMatrixTSub_const<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMatrixTSparseRow_constlEfloatgR = { "TMatrixTSparseRow_const<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMatrixTSparseDiag_constlEfloatgR = { "TMatrixTSparseDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMatrixTColumnlEfloatgR = { "TMatrixTColumn<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMatrixTDiaglEfloatgR = { "TMatrixTDiag<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMatrixTFlatlEfloatgR = { "TMatrixTFlat<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMatrixTSublEfloatgR = { "TMatrixTSub<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMatrixTSparseRowlEfloatgR = { "TMatrixTSparseRow<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TMatrixTSparseDiaglEfloatgR = { "TMatrixTSparseDiag<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGeoHMatrix = { "TGeoHMatrix" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TTree = { "TTree" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TSelector = { "TSelector" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TSelectorDraw = { "TSelectorDraw" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEventList = { "TEventList" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveSelectorToEventList = { "TEveSelectorToEventList" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEvePointSelector = { "TEvePointSelector" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEvePointSelectorConsumer = { "TEvePointSelectorConsumer" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEvePointSelectorConsumercLcLETreeVarType_e = { "TEvePointSelectorConsumer::ETreeVarType_e" , 101 , -1 };
G__linked_taginfo G__G__Eve1LN_TEvePathMarkTlEfloatgR = { "TEvePathMarkT<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEvePathMarkTlEfloatgRcLcLEType_e = { "TEvePathMarkT<float>::EType_e" , 101 , -1 };
G__linked_taginfo G__G__Eve1LN_TEvePathMarkTlEdoublegR = { "TEvePathMarkT<double>" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEvePathMarkTlEdoublegRcLcLEType_e = { "TEvePathMarkT<double>::EType_e" , 101 , -1 };
G__linked_taginfo G__G__Eve1LN_TParticle = { "TParticle" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveMCTrack = { "TEveMCTrack" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveHit = { "TEveHit" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveCluster = { "TEveCluster" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveRecTrack = { "TEveRecTrack" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveRecKink = { "TEveRecKink" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveRecV0 = { "TEveRecV0" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveRecCascade = { "TEveRecCascade" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveMCRecCrossRef = { "TEveMCRecCrossRef" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveVSD = { "TEveVSD" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveWindow = { "TEveWindow" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveWindowSlot = { "TEveWindowSlot" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveWindowFrame = { "TEveWindowFrame" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveWindowPack = { "TEveWindowPack" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveWindowTab = { "TEveWindowTab" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGPack = { "TGPack" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveCompositeFrame = { "TEveCompositeFrame" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveCompositeFrameInMainFrame = { "TEveCompositeFrameInMainFrame" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveCompositeFrameInPack = { "TEveCompositeFrameInPack" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveCompositeFrameInTab = { "TEveCompositeFrameInTab" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGLSAViewer = { "TGLSAViewer" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TGLEmbeddedViewer = { "TGLEmbeddedViewer" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveViewerListEditor = { "TEveViewerListEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveWindowEditor = { "TEveWindowEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve1LN_TEveSecondarySelectable = { "TEveSecondarySelectable" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Eve1() {
  G__G__Eve1LN_TClass.tagnum = -1 ;
  G__G__Eve1LN_TBuffer.tagnum = -1 ;
  G__G__Eve1LN_TDirectory.tagnum = -1 ;
  G__G__Eve1LN_TMemberInspector.tagnum = -1 ;
  G__G__Eve1LN_TObject.tagnum = -1 ;
  G__G__Eve1LN_TNamed.tagnum = -1 ;
  G__G__Eve1LN_TString.tagnum = -1 ;
  G__G__Eve1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__Eve1LN_string.tagnum = -1 ;
  G__G__Eve1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__Eve1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve1LN_TList.tagnum = -1 ;
  G__G__Eve1LN_TObjArray.tagnum = -1 ;
  G__G__Eve1LN_TTimer.tagnum = -1 ;
  G__G__Eve1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve1LN_TPRegexp.tagnum = -1 ;
  G__G__Eve1LN_Event_t.tagnum = -1 ;
  G__G__Eve1LN_exception.tagnum = -1 ;
  G__G__Eve1LN_TVirtualPad.tagnum = -1 ;
  G__G__Eve1LN_TGeoManager.tagnum = -1 ;
  G__G__Eve1LN_TEveElement.tagnum = -1 ;
  G__G__Eve1LN_TEveUtil.tagnum = -1 ;
  G__G__Eve1LN_TEveException.tagnum = -1 ;
  G__G__Eve1LN_TEvePadHolder.tagnum = -1 ;
  G__G__Eve1LN_TEveGeoManagerHolder.tagnum = -1 ;
  G__G__Eve1LN_TEveRefCnt.tagnum = -1 ;
  G__G__Eve1LN_TEveRefBackPtr.tagnum = -1 ;
  G__G__Eve1LN_lesslETEveElementmUgR.tagnum = -1 ;
  G__G__Eve1LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve1LN_TEveProjection.tagnum = -1 ;
  G__G__Eve1LN_TEveProjected.tagnum = -1 ;
  G__G__Eve1LN_TEveProjectionManager.tagnum = -1 ;
  G__G__Eve1LN_TEveProjectable.tagnum = -1 ;
  G__G__Eve1LN_listlETEveProjectedmUcOallocatorlETEveProjectedmUgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_listlETEveProjectedmUcOallocatorlETEveProjectedmUgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve1LN_allocatorlETEveElementmUgR.tagnum = -1 ;
  G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLreverse_iterator.tagnum = -1 ;
  G__G__Eve1LN_pairlEsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiteratorcOboolgR.tagnum = -1 ;
  G__G__Eve1LN_TFile.tagnum = -1 ;
  G__G__Eve1LN_TRef.tagnum = -1 ;
  G__G__Eve1LN_TGListTree.tagnum = -1 ;
  G__G__Eve1LN_TGListTreeItem.tagnum = -1 ;
  G__G__Eve1LN_TGPicture.tagnum = -1 ;
  G__G__Eve1LN_TEveCompound.tagnum = -1 ;
  G__G__Eve1LN_TEveTrans.tagnum = -1 ;
  G__G__Eve1LN_TGeoMatrix.tagnum = -1 ;
  G__G__Eve1LN_TEveManager.tagnum = -1 ;
  G__G__Eve1LN_TEveElementcLcLTEveListTreeInfo.tagnum = -1 ;
  G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgR.tagnum = -1 ;
  G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgRcLcLreverse_iterator.tagnum = -1 ;
  G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLreverse_iterator.tagnum = -1 ;
  G__G__Eve1LN_TEveElementcLcLECompoundSelectionColorBits.tagnum = -1 ;
  G__G__Eve1LN_TEveElementcLcLEDestruct.tagnum = -1 ;
  G__G__Eve1LN_TEveElementcLcLEChangeBits.tagnum = -1 ;
  G__G__Eve1LN_TEveElementObjectPtr.tagnum = -1 ;
  G__G__Eve1LN_TEveElementList.tagnum = -1 ;
  G__G__Eve1LN_TEveElementListProjected.tagnum = -1 ;
  G__G__Eve1LN_TGObject.tagnum = -1 ;
  G__G__Eve1LN_TQObject.tagnum = -1 ;
  G__G__Eve1LN_TGWindow.tagnum = -1 ;
  G__G__Eve1LN_TAttLine.tagnum = -1 ;
  G__G__Eve1LN_TAttFill.tagnum = -1 ;
  G__G__Eve1LN_TGFrame.tagnum = -1 ;
  G__G__Eve1LN_TGCompositeFrame.tagnum = -1 ;
  G__G__Eve1LN_TGLayoutHints.tagnum = -1 ;
  G__G__Eve1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__Eve1LN_TGTextButton.tagnum = -1 ;
  G__G__Eve1LN_TGVerticalFrame.tagnum = -1 ;
  G__G__Eve1LN_TGHorizontalFrame.tagnum = -1 ;
  G__G__Eve1LN_TGMainFrame.tagnum = -1 ;
  G__G__Eve1LN_TBrowserImp.tagnum = -1 ;
  G__G__Eve1LN_TGTab.tagnum = -1 ;
  G__G__Eve1LN_TGMenuBar.tagnum = -1 ;
  G__G__Eve1LN_TGPopupMenu.tagnum = -1 ;
  G__G__Eve1LN_TGStatusBar.tagnum = -1 ;
  G__G__Eve1LN_TRootBrowser.tagnum = -1 ;
  G__G__Eve1LN_TGCanvas.tagnum = -1 ;
  G__G__Eve1LN_TGWidget.tagnum = -1 ;
  G__G__Eve1LN_TContextMenu.tagnum = -1 ;
  G__G__Eve1LN_TGFileBrowser.tagnum = -1 ;
  G__G__Eve1LN_TGSplitter.tagnum = -1 ;
  G__G__Eve1LN_TEveGedEditor.tagnum = -1 ;
  G__G__Eve1LN_TEveListTreeItem.tagnum = -1 ;
  G__G__Eve1LN_TEveGListTreeEditorFrame.tagnum = -1 ;
  G__G__Eve1LN_TEveBrowser.tagnum = -1 ;
  G__G__Eve1LN_TEveChunkManager.tagnum = -1 ;
  G__G__Eve1LN_vectorlETArrayCmUcOallocatorlETArrayCmUgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_reverse_iteratorlEvectorlETArrayCmUcOallocatorlETArrayCmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve1LN_TEveChunkManagercLcLiterator.tagnum = -1 ;
  G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve1LN_TEveCompoundProjected.tagnum = -1 ;
  G__G__Eve1LN_TCanvas.tagnum = -1 ;
  G__G__Eve1LN_TGLabel.tagnum = -1 ;
  G__G__Eve1LN_TGedEditor.tagnum = -1 ;
  G__G__Eve1LN_TGedFrame.tagnum = -1 ;
  G__G__Eve1LN_TGCheckButton.tagnum = -1 ;
  G__G__Eve1LN_TGNumberEntry.tagnum = -1 ;
  G__G__Eve1LN_TGColorSelect.tagnum = -1 ;
  G__G__Eve1LN_TEveTransSubEditor.tagnum = -1 ;
  G__G__Eve1LN_TEveElementEditor.tagnum = -1 ;
  G__G__Eve1LN_TEveEventManager.tagnum = -1 ;
  G__G__Eve1LN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve1LN_TGButton.tagnum = -1 ;
  G__G__Eve1LN_TGNumberFormat.tagnum = -1 ;
  G__G__Eve1LN_TGNumberFormatcLcLEStyle.tagnum = -1 ;
  G__G__Eve1LN_TGHSlider.tagnum = -1 ;
  G__G__Eve1LN_TGDoubleHSlider.tagnum = -1 ;
  G__G__Eve1LN_TEveGValuatorBase.tagnum = -1 ;
  G__G__Eve1LN_TEveGValuator.tagnum = -1 ;
  G__G__Eve1LN_TEveGDoubleValuator.tagnum = -1 ;
  G__G__Eve1LN_TEveGTriVecValuator.tagnum = -1 ;
  G__G__Eve1LN_TVirtualPadEditor.tagnum = -1 ;
  G__G__Eve1LN_TMap.tagnum = -1 ;
  G__G__Eve1LN_TEveGedNameFrame.tagnum = -1 ;
  G__G__Eve1LN_TEveGedNameTextButton.tagnum = -1 ;
  G__G__Eve1LN_TMacro.tagnum = -1 ;
  G__G__Eve1LN_TEveMacro.tagnum = -1 ;
  G__G__Eve1LN_TSysEvtHandler.tagnum = -1 ;
  G__G__Eve1LN_TStdExceptionHandler.tagnum = -1 ;
  G__G__Eve1LN_TStdExceptionHandlercLcLEStatus.tagnum = -1 ;
  G__G__Eve1LN_TAttPad.tagnum = -1 ;
  G__G__Eve1LN_TVirtualViewer3D.tagnum = -1 ;
  G__G__Eve1LN_TExMap.tagnum = -1 ;
  G__G__Eve1LN_TFolder.tagnum = -1 ;
  G__G__Eve1LN_TGLViewer.tagnum = -1 ;
  G__G__Eve1LN_TEveSelection.tagnum = -1 ;
  G__G__Eve1LN_TEveViewer.tagnum = -1 ;
  G__G__Eve1LN_TEveViewerList.tagnum = -1 ;
  G__G__Eve1LN_TEveScene.tagnum = -1 ;
  G__G__Eve1LN_TEveSceneList.tagnum = -1 ;
  G__G__Eve1LN_TEveWindowManager.tagnum = -1 ;
  G__G__Eve1LN_TEveManagercLcLTRedrawDisabler.tagnum = -1 ;
  G__G__Eve1LN_TEveManagercLcLTExceptionHandler.tagnum = -1 ;
  G__G__Eve1LN_TPad.tagnum = -1 ;
  G__G__Eve1LN_TEvePad.tagnum = -1 ;
  G__G__Eve1LN_TEveParamList.tagnum = -1 ;
  G__G__Eve1LN_TEveParamListEditor.tagnum = -1 ;
  G__G__Eve1LN_TEveParamListcLcLFloatConfig_t.tagnum = -1 ;
  G__G__Eve1LN_vectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_vectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve1LN_reverse_iteratorlEvectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve1LN_TEveParamListcLcLIntConfig_t.tagnum = -1 ;
  G__G__Eve1LN_vectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_vectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve1LN_reverse_iteratorlEvectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve1LN_TEveParamListcLcLBoolConfig_t.tagnum = -1 ;
  G__G__Eve1LN_vectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_vectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve1LN_reverse_iteratorlEvectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve1LN_vectorlETGNumberEntrymUcOallocatorlETGNumberEntrymUgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_reverse_iteratorlEvectorlETGNumberEntrymUcOallocatorlETGNumberEntrymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve1LN_vectorlETGCheckButtonmUcOallocatorlETGCheckButtonmUgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_reverse_iteratorlEvectorlETGCheckButtonmUcOallocatorlETGCheckButtonmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve1LN_TGComboBox.tagnum = -1 ;
  G__G__Eve1LN_TEveProjectionAxes.tagnum = -1 ;
  G__G__Eve1LN_TEveProjectionAxesEditor.tagnum = -1 ;
  G__G__Eve1LN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR.tagnum = -1 ;
  G__G__Eve1LN_reverse_iteratorlEvectorlETGLPlanecOallocatorlETGLPlanegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve1LN_pairlEboolcOTGLLine3gR.tagnum = -1 ;
  G__G__Eve1LN_pairlEboolcOTGLVertex3gR.tagnum = -1 ;
  G__G__Eve1LN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR.tagnum = -1 ;
  G__G__Eve1LN_reverse_iteratorlEvectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve1LN_pairlEintcOintgR.tagnum = -1 ;
  G__G__Eve1LN_pairlEdoublecOdoublegR.tagnum = -1 ;
  G__G__Eve1LN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
  G__G__Eve1LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve1LN_TBuffer3D.tagnum = -1 ;
  G__G__Eve1LN_TGLRnrCtx.tagnum = -1 ;
  G__G__Eve1LN_TGLSelectRecord.tagnum = -1 ;
  G__G__Eve1LN_TGLSceneBase.tagnum = -1 ;
  G__G__Eve1LN_TGLLogicalShape.tagnum = -1 ;
  G__G__Eve1LN_TGLObject.tagnum = -1 ;
  G__G__Eve1LN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve1LN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_TAttAxis.tagnum = -1 ;
  G__G__Eve1LN_TGLAxisPainter.tagnum = -1 ;
  G__G__Eve1LN_pairlEfloatcOfloatgR.tagnum = -1 ;
  G__G__Eve1LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve1LN_pairlEfloatcOintgR.tagnum = -1 ;
  G__G__Eve1LN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_reverse_iteratorlEvectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve1LN_TEveProjectionAxesGL.tagnum = -1 ;
  G__G__Eve1LN_TAtt3D.tagnum = -1 ;
  G__G__Eve1LN_TAttBBox.tagnum = -1 ;
  G__G__Eve1LN_TEveProjectionAxescLcLELabMode.tagnum = -1 ;
  G__G__Eve1LN_TEveProjectionAxescLcLEAxesMode.tagnum = -1 ;
  G__G__Eve1LN_TEveProjectionManagerEditor.tagnum = -1 ;
  G__G__Eve1LN_TVector3.tagnum = -1 ;
  G__G__Eve1LN_TEveVectorTlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TEveVectorTlEdoublegR.tagnum = -1 ;
  G__G__Eve1LN_TEveVector4TlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TEveVector4TlEdoublegR.tagnum = -1 ;
  G__G__Eve1LN_TEveVector2TlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TEveVector2TlEdoublegR.tagnum = -1 ;
  G__G__Eve1LN_TEveProjectioncLcLEPType_e.tagnum = -1 ;
  G__G__Eve1LN_TEveProjectioncLcLEPProc_e.tagnum = -1 ;
  G__G__Eve1LN_TEveProjectioncLcLEGeoMode_e.tagnum = -1 ;
  G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t.tagnum = -1 ;
  G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve1LN_reverse_iteratorlEvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve1LN_TEveRhoZProjection.tagnum = -1 ;
  G__G__Eve1LN_TEveRPhiProjection.tagnum = -1 ;
  G__G__Eve1LN_TEve3DProjection.tagnum = -1 ;
  G__G__Eve1LN_TGLScenePad.tagnum = -1 ;
  G__G__Eve1LN_TGLSceneInfo.tagnum = -1 ;
  G__G__Eve1LN_TEveSceneInfo.tagnum = -1 ;
  G__G__Eve1LN_TEveSelectioncLcLEPickToSelect.tagnum = -1 ;
  G__G__Eve1LN_maplETEveElementmUcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_maplETEveElementmUcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRsPgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve1LN_TEveTransEditor.tagnum = -1 ;
  G__G__Eve1LN_TMatrixTBaselEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TMatrixTBaselEdoublegR.tagnum = -1 ;
  G__G__Eve1LN_TVectorTlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TVectorTlEdoublegR.tagnum = -1 ;
  G__G__Eve1LN_TElementActionTlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TElementPosActionTlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TMatrixTlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TMatrixTRow_constlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TMatrixTRowlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TMatrixTDiag_constlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TMatrixTColumn_constlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TMatrixTFlat_constlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TMatrixTSub_constlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TMatrixTSparseRow_constlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TMatrixTSparseDiag_constlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TMatrixTColumnlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TMatrixTDiaglEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TMatrixTFlatlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TMatrixTSublEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TMatrixTSparseRowlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TMatrixTSparseDiaglEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TGeoHMatrix.tagnum = -1 ;
  G__G__Eve1LN_TTree.tagnum = -1 ;
  G__G__Eve1LN_TSelector.tagnum = -1 ;
  G__G__Eve1LN_TSelectorDraw.tagnum = -1 ;
  G__G__Eve1LN_TEventList.tagnum = -1 ;
  G__G__Eve1LN_TEveSelectorToEventList.tagnum = -1 ;
  G__G__Eve1LN_TEvePointSelector.tagnum = -1 ;
  G__G__Eve1LN_TEvePointSelectorConsumer.tagnum = -1 ;
  G__G__Eve1LN_TEvePointSelectorConsumercLcLETreeVarType_e.tagnum = -1 ;
  G__G__Eve1LN_TEvePathMarkTlEfloatgR.tagnum = -1 ;
  G__G__Eve1LN_TEvePathMarkTlEfloatgRcLcLEType_e.tagnum = -1 ;
  G__G__Eve1LN_TEvePathMarkTlEdoublegR.tagnum = -1 ;
  G__G__Eve1LN_TEvePathMarkTlEdoublegRcLcLEType_e.tagnum = -1 ;
  G__G__Eve1LN_TParticle.tagnum = -1 ;
  G__G__Eve1LN_TEveMCTrack.tagnum = -1 ;
  G__G__Eve1LN_TEveHit.tagnum = -1 ;
  G__G__Eve1LN_TEveCluster.tagnum = -1 ;
  G__G__Eve1LN_TEveRecTrack.tagnum = -1 ;
  G__G__Eve1LN_TEveRecKink.tagnum = -1 ;
  G__G__Eve1LN_TEveRecV0.tagnum = -1 ;
  G__G__Eve1LN_TEveRecCascade.tagnum = -1 ;
  G__G__Eve1LN_TEveMCRecCrossRef.tagnum = -1 ;
  G__G__Eve1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
  G__G__Eve1LN_TEveVSD.tagnum = -1 ;
  G__G__Eve1LN_TEveWindow.tagnum = -1 ;
  G__G__Eve1LN_TEveWindowSlot.tagnum = -1 ;
  G__G__Eve1LN_TEveWindowFrame.tagnum = -1 ;
  G__G__Eve1LN_TEveWindowPack.tagnum = -1 ;
  G__G__Eve1LN_TEveWindowTab.tagnum = -1 ;
  G__G__Eve1LN_TGPack.tagnum = -1 ;
  G__G__Eve1LN_TEveCompositeFrame.tagnum = -1 ;
  G__G__Eve1LN_TEveCompositeFrameInMainFrame.tagnum = -1 ;
  G__G__Eve1LN_TEveCompositeFrameInPack.tagnum = -1 ;
  G__G__Eve1LN_TEveCompositeFrameInTab.tagnum = -1 ;
  G__G__Eve1LN_TGLSAViewer.tagnum = -1 ;
  G__G__Eve1LN_TGLEmbeddedViewer.tagnum = -1 ;
  G__G__Eve1LN_TEveViewerListEditor.tagnum = -1 ;
  G__G__Eve1LN_TEveWindowEditor.tagnum = -1 ;
  G__G__Eve1LN_TEveSecondarySelectable.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Eve1() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TClass);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TDirectory);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TObject);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TString);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_string);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TList);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TObjArray);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TTimer);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TPRegexp);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_Event_t);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_exception);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TVirtualPad);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGeoManager);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveElement),sizeof(TEveElement),-1,298752,"Base class for TEveUtil visualization elements, providing hierarchy management, rendering control and list-tree item management.",G__setup_memvarTEveElement,G__setup_memfuncTEveElement);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveUtil),sizeof(TEveUtil),-1,263168,"Standard utility functions for Reve.",G__setup_memvarTEveUtil,G__setup_memfuncTEveUtil);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveException),sizeof(TEveException),-1,296192,"Exception-type thrown by Eve classes.",G__setup_memvarTEveException,G__setup_memfuncTEveException);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEvePadHolder),sizeof(TEvePadHolder),-1,298496,"Exception-safe wrapper for temporary setting of gPad variable.",G__setup_memvarTEvePadHolder,G__setup_memfuncTEvePadHolder);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveGeoManagerHolder),sizeof(TEveGeoManagerHolder),-1,265984,"Exception-safe wrapper for temporary setting of gGeoManager variable.",G__setup_memvarTEveGeoManagerHolder,G__setup_memfuncTEveGeoManagerHolder);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveRefCnt),sizeof(TEveRefCnt),-1,265984,"Base-class for reference-counted objects.",G__setup_memvarTEveRefCnt,G__setup_memfuncTEveRefCnt);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveRefBackPtr),sizeof(TEveRefBackPtr),-1,265984,"Base-class for reference-counted objects with reverse references to TEveElement objects.",G__setup_memvarTEveRefBackPtr,G__setup_memfuncTEveRefBackPtr);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_lesslETEveElementmUgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgRcLcLiterator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveProjection),sizeof(TEveProjection),-1,263427,"Base for specific classes that implement non-linear projections.",G__setup_memvarTEveProjection,G__setup_memfuncTEveProjection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveProjected),sizeof(TEveProjected),-1,265985,"Abstract base class for classes that hold results of a non-linear projection transformation.",G__setup_memvarTEveProjected,G__setup_memfuncTEveProjected);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveProjectionManager),sizeof(TEveProjectionManager),-1,327424,"Manager class for steering of projections and managing projected objects.",G__setup_memvarTEveProjectionManager,G__setup_memfuncTEveProjectionManager);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveProjectable),sizeof(TEveProjectable),-1,265985,"Abstract base class for classes that can be transformed with non-linear projections.",G__setup_memvarTEveProjectable,G__setup_memfuncTEveProjectable);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_listlETEveProjectedmUcOallocatorlETEveProjectedmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_listlETEveProjectedmUcOallocatorlETEveProjectedmUgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_allocatorlETEveElementmUgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR),sizeof(set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >),-1,3840,(char*)NULL,G__setup_memvarsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR,G__setup_memfuncsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator),sizeof(set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >::iterator),-1,2816,(char*)NULL,G__setup_memvarsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator,G__setup_memfuncsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLreverse_iterator);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_pairlEsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcLcLiteratorcOboolgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TFile);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TRef);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGListTree);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGListTreeItem);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGPicture);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveCompound),sizeof(TEveCompound),-1,327424,"Container for managing compounds of TEveElements.",G__setup_memvarTEveCompound,G__setup_memfuncTEveCompound);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveTrans),sizeof(TEveTrans),-1,130816,"Column-major 4x4 transforamtion matrix for homogeneous coordinates.",G__setup_memvarTEveTrans,G__setup_memfuncTEveTrans);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGeoMatrix);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveManager),sizeof(TEveManager),-1,298496,"Eve application manager.",G__setup_memvarTEveManager,G__setup_memfuncTEveManager);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveElementcLcLTEveListTreeInfo),sizeof(TEveElement::TEveListTreeInfo),-1,298752,"Structure agregating data for a render element image in a list tree.",G__setup_memvarTEveElementcLcLTEveListTreeInfo,G__setup_memfuncTEveElementcLcLTEveListTreeInfo);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgRcLcLreverse_iterator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR),sizeof(list<TEveElement*,allocator<TEveElement*> >),-1,36608,(char*)NULL,G__setup_memvarlistlETEveElementmUcOallocatorlETEveElementmUgRsPgR,G__setup_memfunclistlETEveElementmUcOallocatorlETEveElementmUgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator),sizeof(list<TEveElement*,allocator<TEveElement*> >::iterator),-1,2816,(char*)NULL,G__setup_memvarlistlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator,G__setup_memfunclistlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgRcLcLreverse_iterator);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveElementcLcLECompoundSelectionColorBits);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveElementcLcLEDestruct);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveElementcLcLEChangeBits);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveElementObjectPtr),sizeof(TEveElementObjectPtr),-1,327168,"TEveElement with external TObject as a holder of visualization data.",G__setup_memvarTEveElementObjectPtr,G__setup_memfuncTEveElementObjectPtr);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveElementList),sizeof(TEveElementList),-1,327424,"List of TEveElement objects with a possibility to limit the class of accepted elements.",G__setup_memvarTEveElementList,G__setup_memfuncTEveElementList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveElementListProjected),sizeof(TEveElementListProjected),-1,327424,"Projected TEveElementList.",G__setup_memvarTEveElementListProjected,G__setup_memfuncTEveElementListProjected);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGObject);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TQObject);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGWindow);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TAttLine);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TAttFill);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGFrame);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGCompositeFrame);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGLayoutHints);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGTextButton);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGVerticalFrame);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGHorizontalFrame);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGMainFrame);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TBrowserImp);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGTab);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGMenuBar);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGPopupMenu);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGStatusBar);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TRootBrowser);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGCanvas);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGWidget);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TContextMenu);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGFileBrowser);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGSplitter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveGedEditor),sizeof(TEveGedEditor),-1,327424,"Specialization of TGedEditor for proper update propagation to TEveManager.",G__setup_memvarTEveGedEditor,G__setup_memfuncTEveGedEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveListTreeItem),sizeof(TEveListTreeItem),-1,298496,"Special llist-tree-item for Eve.",G__setup_memvarTEveListTreeItem,G__setup_memfuncTEveListTreeItem);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveGListTreeEditorFrame),sizeof(TEveGListTreeEditorFrame),-1,327424,"Composite GUI frame for parallel display of a TGListTree and TEveGedEditor.",G__setup_memvarTEveGListTreeEditorFrame,G__setup_memfuncTEveGListTreeEditorFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveBrowser),sizeof(TEveBrowser),-1,327168,"Specialization of TRootBrowser for Eve.",G__setup_memvarTEveBrowser,G__setup_memfuncTEveBrowser);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveChunkManager),sizeof(TEveChunkManager),-1,298752,"Vector-like container with chunked memory allocation.",G__setup_memvarTEveChunkManager,G__setup_memfuncTEveChunkManager);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlETArrayCmUcOallocatorlETArrayCmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_reverse_iteratorlEvectorlETArrayCmUcOallocatorlETArrayCmUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveChunkManagercLcLiterator),sizeof(TEveChunkManager::iterator),-1,100864,(char*)NULL,G__setup_memvarTEveChunkManagercLcLiterator,G__setup_memfuncTEveChunkManagercLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgRcLcLiterator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveCompoundProjected),sizeof(TEveCompoundProjected),-1,327424,"Projected TEveCompund container.",G__setup_memvarTEveCompoundProjected,G__setup_memfuncTEveCompoundProjected);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TCanvas);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGLabel);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGedEditor);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGedFrame);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGCheckButton);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGNumberEntry);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGColorSelect);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveTransSubEditor),sizeof(TEveTransSubEditor),-1,327168,"Sub-editor for TEveTrans class.",G__setup_memvarTEveTransSubEditor,G__setup_memfuncTEveTransSubEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveElementEditor),sizeof(TEveElementEditor),-1,327424,"Editor for TEveElement class.",G__setup_memvarTEveElementEditor,G__setup_memfuncTEveElementEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveEventManager),sizeof(TEveEventManager),-1,324864,"Base class for event management and navigation.",G__setup_memvarTEveEventManager,G__setup_memfuncTEveEventManager);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlETStringcOallocatorlETStringgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGButton);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGNumberFormat);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGNumberFormatcLcLEStyle);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGHSlider);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGDoubleHSlider);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveGValuatorBase),sizeof(TEveGValuatorBase),-1,327169,"Base class for composite GUI elements for setting of numeric values.",G__setup_memvarTEveGValuatorBase,G__setup_memfuncTEveGValuatorBase);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveGValuator),sizeof(TEveGValuator),-1,327168,"Composite GUI element for single value selection (supports label, number-entry and slider).",G__setup_memvarTEveGValuator,G__setup_memfuncTEveGValuator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveGDoubleValuator),sizeof(TEveGDoubleValuator),-1,327168,"Composite GUI element for selection of range (label, two number-entries and double-slider).",G__setup_memvarTEveGDoubleValuator,G__setup_memfuncTEveGDoubleValuator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveGTriVecValuator),sizeof(TEveGTriVecValuator),-1,327168,"Composite GUI element for setting three numerical values (label, three number-entries).",G__setup_memvarTEveGTriVecValuator,G__setup_memfuncTEveGTriVecValuator);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TVirtualPadEditor);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMap);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveGedNameFrame),sizeof(TEveGedNameFrame),-1,327424,"Top name-frame used in EVE.",G__setup_memvarTEveGedNameFrame,G__setup_memfuncTEveGedNameFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveGedNameTextButton),sizeof(TEveGedNameTextButton),-1,327168,"Button for GED name-frame.",G__setup_memvarTEveGedNameTextButton,G__setup_memfuncTEveGedNameTextButton);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMacro);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveMacro),sizeof(TEveMacro),-1,325376,"TMacro wrapper (attempting to fix issues with different macro loading and execution schemes).",G__setup_memvarTEveMacro,G__setup_memfuncTEveMacro);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TSysEvtHandler);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TStdExceptionHandler);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TStdExceptionHandlercLcLEStatus);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TAttPad);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TVirtualViewer3D);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TExMap);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TFolder);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGLViewer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveSelection),sizeof(TEveSelection),-1,327424,"Container for selected and highlighted elements.",G__setup_memvarTEveSelection,G__setup_memfuncTEveSelection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveViewer),sizeof(TEveViewer),-1,327424,"Reve representation of TGLViewer.",G__setup_memvarTEveViewer,G__setup_memfuncTEveViewer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveViewerList),sizeof(TEveViewerList),-1,327424,"List of Viewers providing common operations on TEveViewer collections.",G__setup_memvarTEveViewerList,G__setup_memfuncTEveViewerList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveScene),sizeof(TEveScene),-1,327424,"Reve representation of TGLScene.",G__setup_memvarTEveScene,G__setup_memfuncTEveScene);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveSceneList),sizeof(TEveSceneList),-1,327424,"List of Scenes providing common operations on TEveScene collections.",G__setup_memvarTEveSceneList,G__setup_memfuncTEveSceneList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveWindowManager),sizeof(TEveWindowManager),-1,327424,"Manager for EVE windows.",G__setup_memvarTEveWindowManager,G__setup_memfuncTEveWindowManager);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveManagercLcLTRedrawDisabler),sizeof(TEveManager::TRedrawDisabler),-1,298496,"Exception-safe EVE redraw-disabler.",G__setup_memvarTEveManagercLcLTRedrawDisabler,G__setup_memfuncTEveManagercLcLTRedrawDisabler);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveManagercLcLTExceptionHandler),sizeof(TEveManager::TExceptionHandler),-1,292096,"Exception handler for Eve exceptions.",G__setup_memvarTEveManagercLcLTExceptionHandler,G__setup_memfuncTEveManagercLcLTExceptionHandler);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TPad);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEvePad),sizeof(TEvePad),-1,324864,"Internal TEveUtil pad class (sub-class of TPad) overriding handling of updates and 3D-viewers.",G__setup_memvarTEvePad,G__setup_memfuncTEvePad);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveParamList),sizeof(TEveParamList),-1,65280,"Eve element to store generic configuration information.",G__setup_memvarTEveParamList,G__setup_memfuncTEveParamList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveParamListEditor),sizeof(TEveParamListEditor),-1,327424,"GUI editor for TEveParamList.",G__setup_memvarTEveParamListEditor,G__setup_memfuncTEveParamListEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveParamListcLcLFloatConfig_t),sizeof(TEveParamList::FloatConfig_t),-1,295168,(char*)NULL,G__setup_memvarTEveParamListcLcLFloatConfig_t,G__setup_memfuncTEveParamListcLcLFloatConfig_t);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_reverse_iteratorlEvectorlETEveParamListcLcLFloatConfig_tcOallocatorlETEveParamListcLcLFloatConfig_tgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveParamListcLcLIntConfig_t),sizeof(TEveParamList::IntConfig_t),-1,295168,(char*)NULL,G__setup_memvarTEveParamListcLcLIntConfig_t,G__setup_memfuncTEveParamListcLcLIntConfig_t);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_reverse_iteratorlEvectorlETEveParamListcLcLIntConfig_tcOallocatorlETEveParamListcLcLIntConfig_tgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveParamListcLcLBoolConfig_t),sizeof(TEveParamList::BoolConfig_t),-1,295168,(char*)NULL,G__setup_memvarTEveParamListcLcLBoolConfig_t,G__setup_memfuncTEveParamListcLcLBoolConfig_t);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_reverse_iteratorlEvectorlETEveParamListcLcLBoolConfig_tcOallocatorlETEveParamListcLcLBoolConfig_tgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlETGNumberEntrymUcOallocatorlETGNumberEntrymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_reverse_iteratorlEvectorlETGNumberEntrymUcOallocatorlETGNumberEntrymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlETGCheckButtonmUcOallocatorlETGCheckButtonmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_reverse_iteratorlEvectorlETGCheckButtonmUcOallocatorlETGCheckButtonmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGComboBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveProjectionAxes),sizeof(TEveProjectionAxes),-1,327168,"Class to draw scales in non-linear projections.",G__setup_memvarTEveProjectionAxes,G__setup_memfuncTEveProjectionAxes);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveProjectionAxesEditor),sizeof(TEveProjectionAxesEditor),-1,327424,"GUI editor for TEveProjectionAxes.",G__setup_memvarTEveProjectionAxesEditor,G__setup_memfuncTEveProjectionAxesEditor);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_reverse_iteratorlEvectorlETGLPlanecOallocatorlETGLPlanegRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_pairlEboolcOTGLLine3gR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_pairlEboolcOTGLVertex3gR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_reverse_iteratorlEvectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_pairlEintcOintgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_pairlEdoublecOdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlEdoublecOallocatorlEdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TBuffer3D);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGLRnrCtx);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGLSelectRecord);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGLSceneBase);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGLLogicalShape);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGLObject);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlEintcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TAttAxis);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGLAxisPainter);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_pairlEfloatcOfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_pairlEfloatcOintgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_reverse_iteratorlEvectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveProjectionAxesGL),sizeof(TEveProjectionAxesGL),-1,298752,"GL renderer class for TEveProjectionAxes.",G__setup_memvarTEveProjectionAxesGL,G__setup_memfuncTEveProjectionAxesGL);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TAtt3D);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TAttBBox);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveProjectionAxescLcLELabMode);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveProjectionAxescLcLEAxesMode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveProjectionManagerEditor),sizeof(TEveProjectionManagerEditor),-1,327424,"Editor for TEveProjectionManager class.",G__setup_memvarTEveProjectionManagerEditor,G__setup_memfuncTEveProjectionManagerEditor);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TVector3);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveVectorTlEfloatgR),sizeof(TEveVectorT<float>),-1,295168,"A three-vector template without TObject inheritance and virtual functions.",G__setup_memvarTEveVectorTlEfloatgR,G__setup_memfuncTEveVectorTlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveVectorTlEdoublegR),sizeof(TEveVectorT<double>),-1,295168,"A three-vector template without TObject inheritance and virtual functions.",G__setup_memvarTEveVectorTlEdoublegR,G__setup_memfuncTEveVectorTlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveVector4TlEfloatgR),sizeof(TEveVector4T<float>),-1,295168,"A four-vector template without TObject inheritance and virtual functions.",G__setup_memvarTEveVector4TlEfloatgR,G__setup_memfuncTEveVector4TlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveVector4TlEdoublegR),sizeof(TEveVector4T<double>),-1,295168,"A four-vector template without TObject inheritance and virtual functions.",G__setup_memvarTEveVector4TlEdoublegR,G__setup_memfuncTEveVector4TlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveVector2TlEfloatgR),sizeof(TEveVector2T<float>),-1,295168,"// A two-vector template without TObject inheritance and virtual functions.",G__setup_memvarTEveVector2TlEfloatgR,G__setup_memfuncTEveVector2TlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveVector2TlEdoublegR),sizeof(TEveVector2T<double>),-1,295168,"// A two-vector template without TObject inheritance and virtual functions.",G__setup_memvarTEveVector2TlEdoublegR,G__setup_memfuncTEveVector2TlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveProjectioncLcLEPType_e);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveProjectioncLcLEPProc_e);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveProjectioncLcLEGeoMode_e);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveProjectioncLcLPreScaleEntry_t),sizeof(TEveProjection::PreScaleEntry_t),-1,296192,(char*)NULL,G__setup_memvarTEveProjectioncLcLPreScaleEntry_t,G__setup_memfuncTEveProjectioncLcLPreScaleEntry_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR),sizeof(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >),-1,36608,(char*)NULL,G__setup_memvarvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR,G__setup_memfuncvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator),sizeof(vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator),-1,35072,(char*)NULL,G__setup_memvarvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator,G__setup_memfuncvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_reverse_iteratorlEvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveRhoZProjection),sizeof(TEveRhoZProjection),-1,263424,"Rho/Z non-linear projection.",G__setup_memvarTEveRhoZProjection,G__setup_memfuncTEveRhoZProjection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveRPhiProjection),sizeof(TEveRPhiProjection),-1,263424,"XY non-linear projection.",G__setup_memvarTEveRPhiProjection,G__setup_memfuncTEveRPhiProjection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEve3DProjection),sizeof(TEve3DProjection),-1,263424,"3D scaling \"projection\"",G__setup_memvarTEve3DProjection,G__setup_memfuncTEve3DProjection);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGLScenePad);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGLSceneInfo);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveSceneInfo),sizeof(TEveSceneInfo),-1,327168,"TEveUtil representation of TGLSceneInfo.",G__setup_memvarTEveSceneInfo,G__setup_memfuncTEveSceneInfo);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveSelectioncLcLEPickToSelect);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_maplETEveElementmUcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_maplETEveElementmUcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOsetlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgRsPgRsPgRsPgRcLcLiterator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveTransEditor),sizeof(TEveTransEditor),-1,327424,"Editor for TEveTrans class.",G__setup_memvarTEveTransEditor,G__setup_memfuncTEveTransEditor);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMatrixTBaselEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMatrixTBaselEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TElementActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TElementPosActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMatrixTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMatrixTRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMatrixTRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMatrixTDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMatrixTColumn_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMatrixTFlat_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMatrixTSub_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMatrixTSparseRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMatrixTSparseDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMatrixTColumnlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMatrixTDiaglEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMatrixTFlatlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMatrixTSublEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMatrixTSparseRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TMatrixTSparseDiaglEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGeoHMatrix);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TTree);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TSelector);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TSelectorDraw);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEventList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveSelectorToEventList),sizeof(TEveSelectorToEventList),-1,326144,"TSelector that stores entry numbers of matching TTree entries into an event-list.",G__setup_memvarTEveSelectorToEventList,G__setup_memfuncTEveSelectorToEventList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEvePointSelector),sizeof(TEvePointSelector),-1,294656,"TSelector for direct extraction of point-like data from a Tree.",G__setup_memvarTEvePointSelector,G__setup_memfuncTEvePointSelector);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEvePointSelectorConsumer),sizeof(TEvePointSelectorConsumer),-1,263425,"Virtual base for classes that can be filled from TTree data via the TEvePointSelector class.",G__setup_memvarTEvePointSelectorConsumer,G__setup_memfuncTEvePointSelectorConsumer);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEvePointSelectorConsumercLcLETreeVarType_e);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEvePathMarkTlEfloatgR),sizeof(TEvePathMarkT<float>),-1,295168,"Template for a special point on a track: position/momentum reference, daughter creation or decay.",G__setup_memvarTEvePathMarkTlEfloatgR,G__setup_memfuncTEvePathMarkTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEvePathMarkTlEfloatgRcLcLEType_e);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEvePathMarkTlEdoublegR),sizeof(TEvePathMarkT<double>),-1,295168,"Template for a special point on a track: position/momentum reference, daughter creation or decay.",G__setup_memvarTEvePathMarkTlEdoublegR,G__setup_memfuncTEvePathMarkTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEvePathMarkTlEdoublegRcLcLEType_e);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TParticle);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveMCTrack),sizeof(TEveMCTrack),-1,326912,"Monte Carlo track (also used in VSD).",G__setup_memvarTEveMCTrack,G__setup_memfuncTEveMCTrack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveHit),sizeof(TEveHit),-1,292096,"Monte Carlo hit (also used in VSD).",G__setup_memvarTEveHit,G__setup_memfuncTEveHit);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveCluster),sizeof(TEveCluster),-1,292096,"Reconstructed cluster (also used in VSD).",G__setup_memvarTEveCluster,G__setup_memfuncTEveCluster);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveRecTrack),sizeof(TEveRecTrack),-1,292096,"Reconstructed track (also used in VSD).",G__setup_memvarTEveRecTrack,G__setup_memfuncTEveRecTrack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveRecKink),sizeof(TEveRecKink),-1,292096,"Reconstructed kink (also used in VSD).",G__setup_memvarTEveRecKink,G__setup_memfuncTEveRecKink);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveRecV0),sizeof(TEveRecV0),-1,292096,"Reconstructed V0 (also used in VSD).",G__setup_memvarTEveRecV0,G__setup_memfuncTEveRecV0);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveRecCascade),sizeof(TEveRecCascade),-1,292096,"Reconstructed Cascade (also used in VSD).",G__setup_memvarTEveRecCascade,G__setup_memfuncTEveRecCascade);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveMCRecCrossRef),sizeof(TEveMCRecCrossRef),-1,292096,"Cross-reference of sim/rec data per particle (also used in VSD).",G__setup_memvarTEveMCRecCrossRef,G__setup_memfuncTEveMCRecCrossRef);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveVSD),sizeof(TEveVSD),-1,294656,"Visualization Summary Data - a collection of trees holding standard event data in experiment independant format.",G__setup_memvarTEveVSD,G__setup_memfuncTEveVSD);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveWindow),sizeof(TEveWindow),-1,327425,"Abstract base-class for eve-windows.",G__setup_memvarTEveWindow,G__setup_memfuncTEveWindow);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveWindowSlot),sizeof(TEveWindowSlot),-1,327424,"An unoccupied eve-window slot.",G__setup_memvarTEveWindowSlot,G__setup_memfuncTEveWindowSlot);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveWindowFrame),sizeof(TEveWindowFrame),-1,327168,"Eve-window containing any TGFrame.",G__setup_memvarTEveWindowFrame,G__setup_memfuncTEveWindowFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveWindowPack),sizeof(TEveWindowPack),-1,327168,"Eve-window containing a TGPack.",G__setup_memvarTEveWindowPack,G__setup_memfuncTEveWindowPack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveWindowTab),sizeof(TEveWindowTab),-1,327168,"Eve-window containing a TGTab.",G__setup_memvarTEveWindowTab,G__setup_memfuncTEveWindowTab);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGPack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveCompositeFrame),sizeof(TEveCompositeFrame),-1,327169,"Composite frame containing eve-window-controls and eve-windows.",G__setup_memvarTEveCompositeFrame,G__setup_memfuncTEveCompositeFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveCompositeFrameInMainFrame),sizeof(TEveCompositeFrameInMainFrame),-1,327168,"Eve-composite-frame that is contained in one tab of a TGTab.",G__setup_memvarTEveCompositeFrameInMainFrame,G__setup_memfuncTEveCompositeFrameInMainFrame);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveCompositeFrameInPack),sizeof(TEveCompositeFrameInPack),-1,327168,"Eve-composite-frame that is contained in a TGPack.",G__setup_memvarTEveCompositeFrameInPack,G__setup_memfuncTEveCompositeFrameInPack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveCompositeFrameInTab),sizeof(TEveCompositeFrameInTab),-1,327168,"Eve-composite-frame that is contained in one tab of a TGTab.",G__setup_memvarTEveCompositeFrameInTab,G__setup_memfuncTEveCompositeFrameInTab);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGLSAViewer);
   G__get_linked_tagnum_fwd(&G__G__Eve1LN_TGLEmbeddedViewer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveViewerListEditor),sizeof(TEveViewerListEditor),-1,327424,"GUI editor for TEveViewerList.",G__setup_memvarTEveViewerListEditor,G__setup_memfuncTEveViewerListEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveWindowEditor),sizeof(TEveWindowEditor),-1,327424,"GUI editor for TEveWindow.",G__setup_memvarTEveWindowEditor,G__setup_memfuncTEveWindowEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve1LN_TEveSecondarySelectable),sizeof(TEveSecondarySelectable),-1,265984,"Semi-abstract interface for classes supporting secondary-selection.",G__setup_memvarTEveSecondarySelectable,G__setup_memfuncTEveSecondarySelectable);
}
extern "C" void G__cpp_setupG__Eve1(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Eve1()");
  G__set_cpp_environmentG__Eve1();
  G__cpp_setup_tagtableG__Eve1();

  G__cpp_setup_inheritanceG__Eve1();

  G__cpp_setup_typetableG__Eve1();

  G__cpp_setup_memvarG__Eve1();

  G__cpp_setup_memfuncG__Eve1();
  G__cpp_setup_globalG__Eve1();
  G__cpp_setup_funcG__Eve1();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Eve1();
  return;
}
class G__cpp_setup_initG__Eve1 {
  public:
    G__cpp_setup_initG__Eve1() { G__add_setup_func("G__Eve1",(G__incsetup)(&G__cpp_setupG__Eve1)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Eve1() { G__remove_setup_func("G__Eve1"); }
};
G__cpp_setup_initG__Eve1 G__cpp_setup_initializerG__Eve1;

---