G__Eve2.cxx

Go to the documentation of this file.

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

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

#define R__DICTIONARY_FILENAME graf3ddIevedIsrcdIG__Eve2
#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__Eve2.h"

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

// START OF SHADOWS

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

namespace ROOT {
   void TEveArrow_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveArrow(void *p = 0);
   static void *newArray_TEveArrow(Long_t size, void *p);
   static void delete_TEveArrow(void *p);
   static void deleteArray_TEveArrow(void *p);
   static void destruct_TEveArrow(void *p);

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

namespace ROOT {
   void TEveArrowEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveArrowEditor(void *p = 0);
   static void *newArray_TEveArrowEditor(Long_t size, void *p);
   static void delete_TEveArrowEditor(void *p);
   static void deleteArray_TEveArrowEditor(void *p);
   static void destruct_TEveArrowEditor(void *p);

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

namespace ROOT {
   void TEveArrowGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveArrowGL(void *p = 0);
   static void *newArray_TEveArrowGL(Long_t size, void *p);
   static void delete_TEveArrowGL(void *p);
   static void deleteArray_TEveArrowGL(void *p);
   static void destruct_TEveArrowGL(void *p);

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

namespace ROOT {
   void TEveBox_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveBox(void *p = 0);
   static void *newArray_TEveBox(Long_t size, void *p);
   static void delete_TEveBox(void *p);
   static void deleteArray_TEveBox(void *p);
   static void destruct_TEveBox(void *p);

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

namespace ROOT {
   void TEveBoxProjected_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveBoxProjected(void *p = 0);
   static void *newArray_TEveBoxProjected(Long_t size, void *p);
   static void delete_TEveBoxProjected(void *p);
   static void deleteArray_TEveBoxProjected(void *p);
   static void destruct_TEveBoxProjected(void *p);

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

namespace ROOT {
   void TEveBoxGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveBoxGL(void *p = 0);
   static void *newArray_TEveBoxGL(Long_t size, void *p);
   static void delete_TEveBoxGL(void *p);
   static void deleteArray_TEveBoxGL(void *p);
   static void destruct_TEveBoxGL(void *p);

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

namespace ROOT {
   void TEveBoxProjectedGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveBoxProjectedGL(void *p = 0);
   static void *newArray_TEveBoxProjectedGL(Long_t size, void *p);
   static void delete_TEveBoxProjectedGL(void *p);
   static void deleteArray_TEveBoxProjectedGL(void *p);
   static void destruct_TEveBoxProjectedGL(void *p);

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

namespace ROOT {
   void TEveShape_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveShape(void *p);
   static void deleteArray_TEveShape(void *p);
   static void destruct_TEveShape(void *p);

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

namespace ROOT {
   void TEveShapeEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveShapeEditor(void *p = 0);
   static void *newArray_TEveShapeEditor(Long_t size, void *p);
   static void delete_TEveShapeEditor(void *p);
   static void deleteArray_TEveShapeEditor(void *p);
   static void destruct_TEveShapeEditor(void *p);

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

namespace ROOT {
   void TEveFrameBox_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveFrameBox(void *p = 0);
   static void *newArray_TEveFrameBox(Long_t size, void *p);
   static void delete_TEveFrameBox(void *p);
   static void deleteArray_TEveFrameBox(void *p);
   static void destruct_TEveFrameBox(void *p);

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

namespace ROOT {
   void TEveFrameBoxGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveFrameBoxGL(void *p);
   static void deleteArray_TEveFrameBoxGL(void *p);
   static void destruct_TEveFrameBoxGL(void *p);

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

namespace ROOT {
   void TEveRGBAPalette_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveRGBAPalette(void *p = 0);
   static void *newArray_TEveRGBAPalette(Long_t size, void *p);
   static void delete_TEveRGBAPalette(void *p);
   static void deleteArray_TEveRGBAPalette(void *p);
   static void destruct_TEveRGBAPalette(void *p);

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

namespace ROOT {
   void TEveRGBAPaletteEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveRGBAPaletteEditor(void *p = 0);
   static void *newArray_TEveRGBAPaletteEditor(Long_t size, void *p);
   static void delete_TEveRGBAPaletteEditor(void *p);
   static void deleteArray_TEveRGBAPaletteEditor(void *p);
   static void destruct_TEveRGBAPaletteEditor(void *p);

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

namespace ROOT {
   void TEveRGBAPaletteSubEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveRGBAPaletteSubEditor(void *p);
   static void deleteArray_TEveRGBAPaletteSubEditor(void *p);
   static void destruct_TEveRGBAPaletteSubEditor(void *p);

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

namespace ROOT {
   void TEveDigitSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveDigitSet(void *p);
   static void deleteArray_TEveDigitSet(void *p);
   static void destruct_TEveDigitSet(void *p);

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

namespace ROOT {
   void TEveDigitSetEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveDigitSetEditor(void *p = 0);
   static void *newArray_TEveDigitSetEditor(Long_t size, void *p);
   static void delete_TEveDigitSetEditor(void *p);
   static void deleteArray_TEveDigitSetEditor(void *p);
   static void destruct_TEveDigitSetEditor(void *p);

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

namespace ROOT {
   void TEveDigitSetGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveDigitSetGL(void *p);
   static void deleteArray_TEveDigitSetGL(void *p);
   static void destruct_TEveDigitSetGL(void *p);

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

namespace ROOT {
   void TEveBoxSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveBoxSet(void *p = 0);
   static void *newArray_TEveBoxSet(Long_t size, void *p);
   static void delete_TEveBoxSet(void *p);
   static void deleteArray_TEveBoxSet(void *p);
   static void destruct_TEveBoxSet(void *p);

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

namespace ROOT {
   void TEveBoxSetGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveBoxSetGL(void *p = 0);
   static void *newArray_TEveBoxSetGL(Long_t size, void *p);
   static void delete_TEveBoxSetGL(void *p);
   static void deleteArray_TEveBoxSetGL(void *p);
   static void destruct_TEveBoxSetGL(void *p);

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

namespace ROOT {
   void TEveCaloData_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveCaloData(void *p);
   static void deleteArray_TEveCaloData(void *p);
   static void destruct_TEveCaloData(void *p);

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

namespace ROOT {
   void TEveCaloDatacLcLSliceInfo_t_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveCaloDatacLcLSliceInfo_t(void *p = 0);
   static void *newArray_TEveCaloDatacLcLSliceInfo_t(Long_t size, void *p);
   static void delete_TEveCaloDatacLcLSliceInfo_t(void *p);
   static void deleteArray_TEveCaloDatacLcLSliceInfo_t(void *p);
   static void destruct_TEveCaloDatacLcLSliceInfo_t(void *p);

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

namespace ROOT {
   void TEveCaloDataVec_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveCaloDataVec(void *p);
   static void deleteArray_TEveCaloDataVec(void *p);
   static void destruct_TEveCaloDataVec(void *p);
   static void streamer_TEveCaloDataVec(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TEveCaloDataHist_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveCaloDataHist(void *p = 0);
   static void *newArray_TEveCaloDataHist(Long_t size, void *p);
   static void delete_TEveCaloDataHist(void *p);
   static void deleteArray_TEveCaloDataHist(void *p);
   static void destruct_TEveCaloDataHist(void *p);

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

namespace ROOT {
   void TEveCaloViz_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveCaloViz(void *p);
   static void deleteArray_TEveCaloViz(void *p);
   static void destruct_TEveCaloViz(void *p);

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

namespace ROOT {
   void TEveCaloVizEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveCaloVizEditor(void *p = 0);
   static void *newArray_TEveCaloVizEditor(Long_t size, void *p);
   static void delete_TEveCaloVizEditor(void *p);
   static void deleteArray_TEveCaloVizEditor(void *p);
   static void destruct_TEveCaloVizEditor(void *p);

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

namespace ROOT {
   void TEveCalo3D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveCalo3D(void *p = 0);
   static void *newArray_TEveCalo3D(Long_t size, void *p);
   static void delete_TEveCalo3D(void *p);
   static void deleteArray_TEveCalo3D(void *p);
   static void destruct_TEveCalo3D(void *p);

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

namespace ROOT {
   void TEveCalo3DGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveCalo3DGL(void *p = 0);
   static void *newArray_TEveCalo3DGL(Long_t size, void *p);
   static void delete_TEveCalo3DGL(void *p);
   static void deleteArray_TEveCalo3DGL(void *p);
   static void destruct_TEveCalo3DGL(void *p);

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

namespace ROOT {
   void TEveCalo2D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveCalo2D(void *p = 0);
   static void *newArray_TEveCalo2D(Long_t size, void *p);
   static void delete_TEveCalo2D(void *p);
   static void deleteArray_TEveCalo2D(void *p);
   static void destruct_TEveCalo2D(void *p);

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

namespace ROOT {
   void TEveCalo2DGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveCalo2DGL(void *p = 0);
   static void *newArray_TEveCalo2DGL(Long_t size, void *p);
   static void delete_TEveCalo2DGL(void *p);
   static void deleteArray_TEveCalo2DGL(void *p);
   static void destruct_TEveCalo2DGL(void *p);

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

namespace ROOT {
   void TEveCaloLego_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveCaloLego(void *p = 0);
   static void *newArray_TEveCaloLego(Long_t size, void *p);
   static void delete_TEveCaloLego(void *p);
   static void deleteArray_TEveCaloLego(void *p);
   static void destruct_TEveCaloLego(void *p);

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

namespace ROOT {
   void TEveCaloLegoGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveCaloLegoGL(void *p = 0);
   static void *newArray_TEveCaloLegoGL(Long_t size, void *p);
   static void delete_TEveCaloLegoGL(void *p);
   static void deleteArray_TEveCaloLegoGL(void *p);
   static void destruct_TEveCaloLegoGL(void *p);

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

namespace ROOT {
   void TEveCaloLegoOverlay_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveCaloLegoOverlay(void *p = 0);
   static void *newArray_TEveCaloLegoOverlay(Long_t size, void *p);
   static void delete_TEveCaloLegoOverlay(void *p);
   static void deleteArray_TEveCaloLegoOverlay(void *p);
   static void destruct_TEveCaloLegoOverlay(void *p);

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

namespace ROOT {
   void TEveCaloLegoEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveCaloLegoEditor(void *p = 0);
   static void *newArray_TEveCaloLegoEditor(Long_t size, void *p);
   static void delete_TEveCaloLegoEditor(void *p);
   static void deleteArray_TEveCaloLegoEditor(void *p);
   static void destruct_TEveCaloLegoEditor(void *p);

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

namespace ROOT {
   void TEveCalo3DEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveCalo3DEditor(void *p = 0);
   static void *newArray_TEveCalo3DEditor(Long_t size, void *p);
   static void delete_TEveCalo3DEditor(void *p);
   static void deleteArray_TEveCalo3DEditor(void *p);
   static void destruct_TEveCalo3DEditor(void *p);

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

namespace ROOT {
   void TEveGeoNode_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveGeoNode(void *p);
   static void deleteArray_TEveGeoNode(void *p);
   static void destruct_TEveGeoNode(void *p);

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

namespace ROOT {
   void TEveGeoTopNode_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveGeoTopNode(void *p);
   static void deleteArray_TEveGeoTopNode(void *p);
   static void destruct_TEveGeoTopNode(void *p);

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

namespace ROOT {
   void TEveGeoNodeEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveGeoNodeEditor(void *p = 0);
   static void *newArray_TEveGeoNodeEditor(Long_t size, void *p);
   static void delete_TEveGeoNodeEditor(void *p);
   static void deleteArray_TEveGeoNodeEditor(void *p);
   static void destruct_TEveGeoNodeEditor(void *p);

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

namespace ROOT {
   void TEveGeoTopNodeEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveGeoTopNodeEditor(void *p = 0);
   static void *newArray_TEveGeoTopNodeEditor(Long_t size, void *p);
   static void delete_TEveGeoTopNodeEditor(void *p);
   static void deleteArray_TEveGeoTopNodeEditor(void *p);
   static void destruct_TEveGeoTopNodeEditor(void *p);

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

namespace ROOT {
   void TEveGeoShapeExtract_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveGeoShapeExtract(void *p = 0);
   static void *newArray_TEveGeoShapeExtract(Long_t size, void *p);
   static void delete_TEveGeoShapeExtract(void *p);
   static void deleteArray_TEveGeoShapeExtract(void *p);
   static void destruct_TEveGeoShapeExtract(void *p);

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

namespace ROOT {
   void TEveGeoShape_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveGeoShape(void *p = 0);
   static void *newArray_TEveGeoShape(Long_t size, void *p);
   static void delete_TEveGeoShape(void *p);
   static void deleteArray_TEveGeoShape(void *p);
   static void destruct_TEveGeoShape(void *p);

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

namespace ROOT {
   void TEveGeoShapeProjected_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveGeoShapeProjected(void *p = 0);
   static void *newArray_TEveGeoShapeProjected(Long_t size, void *p);
   static void delete_TEveGeoShapeProjected(void *p);
   static void deleteArray_TEveGeoShapeProjected(void *p);
   static void destruct_TEveGeoShapeProjected(void *p);

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

namespace ROOT {
   void TEveGeoPolyShape_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveGeoPolyShape(void *p = 0);
   static void *newArray_TEveGeoPolyShape(Long_t size, void *p);
   static void delete_TEveGeoPolyShape(void *p);
   static void deleteArray_TEveGeoPolyShape(void *p);
   static void destruct_TEveGeoPolyShape(void *p);

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

namespace ROOT {
   void TEveGridStepper_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveGridStepper(void *p = 0);
   static void *newArray_TEveGridStepper(Long_t size, void *p);
   static void delete_TEveGridStepper(void *p);
   static void deleteArray_TEveGridStepper(void *p);
   static void destruct_TEveGridStepper(void *p);

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

namespace ROOT {
   void TEveGridStepperSubEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveGridStepperSubEditor(void *p);
   static void deleteArray_TEveGridStepperSubEditor(void *p);
   static void destruct_TEveGridStepperSubEditor(void *p);

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

namespace ROOT {
   void TEveGridStepperEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveGridStepperEditor(void *p = 0);
   static void *newArray_TEveGridStepperEditor(Long_t size, void *p);
   static void delete_TEveGridStepperEditor(void *p);
   static void deleteArray_TEveGridStepperEditor(void *p);
   static void destruct_TEveGridStepperEditor(void *p);

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

namespace ROOT {
   void TEveLegoEventHandler_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveLegoEventHandler(void *p);
   static void deleteArray_TEveLegoEventHandler(void *p);
   static void destruct_TEveLegoEventHandler(void *p);

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

namespace ROOT {
   void TEveLine_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveLine(void *p = 0);
   static void *newArray_TEveLine(Long_t size, void *p);
   static void delete_TEveLine(void *p);
   static void deleteArray_TEveLine(void *p);
   static void destruct_TEveLine(void *p);

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

namespace ROOT {
   void TEveLineEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveLineEditor(void *p = 0);
   static void *newArray_TEveLineEditor(Long_t size, void *p);
   static void delete_TEveLineEditor(void *p);
   static void deleteArray_TEveLineEditor(void *p);
   static void destruct_TEveLineEditor(void *p);

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

namespace ROOT {
   void TEveLineGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveLineGL(void *p = 0);
   static void *newArray_TEveLineGL(Long_t size, void *p);
   static void delete_TEveLineGL(void *p);
   static void deleteArray_TEveLineGL(void *p);
   static void destruct_TEveLineGL(void *p);

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

namespace ROOT {
   void TEvePointSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvePointSet(void *p = 0);
   static void *newArray_TEvePointSet(Long_t size, void *p);
   static void delete_TEvePointSet(void *p);
   static void deleteArray_TEvePointSet(void *p);
   static void destruct_TEvePointSet(void *p);

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

namespace ROOT {
   void TEvePointSetArray_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvePointSetArray(void *p = 0);
   static void *newArray_TEvePointSetArray(Long_t size, void *p);
   static void delete_TEvePointSetArray(void *p);
   static void deleteArray_TEvePointSetArray(void *p);
   static void destruct_TEvePointSetArray(void *p);

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

namespace ROOT {
   void TEvePointSetArrayEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvePointSetArrayEditor(void *p = 0);
   static void *newArray_TEvePointSetArrayEditor(Long_t size, void *p);
   static void delete_TEvePointSetArrayEditor(void *p);
   static void deleteArray_TEvePointSetArrayEditor(void *p);
   static void destruct_TEvePointSetArrayEditor(void *p);

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

namespace ROOT {
   void TEvePointSetProjected_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvePointSetProjected(void *p = 0);
   static void *newArray_TEvePointSetProjected(Long_t size, void *p);
   static void delete_TEvePointSetProjected(void *p);
   static void deleteArray_TEvePointSetProjected(void *p);
   static void destruct_TEvePointSetProjected(void *p);

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

namespace ROOT {
   void TEveLineProjected_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveLineProjected(void *p = 0);
   static void *newArray_TEveLineProjected(Long_t size, void *p);
   static void delete_TEveLineProjected(void *p);
   static void deleteArray_TEveLineProjected(void *p);
   static void destruct_TEveLineProjected(void *p);

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

namespace ROOT {
   void TEvePolygonSetProjected_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvePolygonSetProjected(void *p = 0);
   static void *newArray_TEvePolygonSetProjected(Long_t size, void *p);
   static void delete_TEvePolygonSetProjected(void *p);
   static void deleteArray_TEvePolygonSetProjected(void *p);
   static void destruct_TEvePolygonSetProjected(void *p);

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

namespace ROOT {
   void TEvePolygonSetProjectedGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvePolygonSetProjectedGL(void *p = 0);
   static void *newArray_TEvePolygonSetProjectedGL(Long_t size, void *p);
   static void delete_TEvePolygonSetProjectedGL(void *p);
   static void deleteArray_TEvePolygonSetProjectedGL(void *p);
   static void destruct_TEvePolygonSetProjectedGL(void *p);

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

namespace ROOT {
   void TEveQuadSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveQuadSet(void *p = 0);
   static void *newArray_TEveQuadSet(Long_t size, void *p);
   static void delete_TEveQuadSet(void *p);
   static void deleteArray_TEveQuadSet(void *p);
   static void destruct_TEveQuadSet(void *p);

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

namespace ROOT {
   void TEveQuadSetGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveQuadSetGL(void *p = 0);
   static void *newArray_TEveQuadSetGL(Long_t size, void *p);
   static void delete_TEveQuadSetGL(void *p);
   static void deleteArray_TEveQuadSetGL(void *p);
   static void destruct_TEveQuadSetGL(void *p);

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

namespace ROOT {
   void TEveStraightLineSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveStraightLineSet(void *p = 0);
   static void *newArray_TEveStraightLineSet(Long_t size, void *p);
   static void delete_TEveStraightLineSet(void *p);
   static void deleteArray_TEveStraightLineSet(void *p);
   static void destruct_TEveStraightLineSet(void *p);

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

namespace ROOT {
   void TEveStraightLineSetProjected_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveStraightLineSetProjected(void *p = 0);
   static void *newArray_TEveStraightLineSetProjected(Long_t size, void *p);
   static void delete_TEveStraightLineSetProjected(void *p);
   static void deleteArray_TEveStraightLineSetProjected(void *p);
   static void destruct_TEveStraightLineSetProjected(void *p);

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

namespace ROOT {
   void TEveScalableStraightLineSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveScalableStraightLineSet(void *p = 0);
   static void *newArray_TEveScalableStraightLineSet(Long_t size, void *p);
   static void delete_TEveScalableStraightLineSet(void *p);
   static void deleteArray_TEveScalableStraightLineSet(void *p);
   static void destruct_TEveScalableStraightLineSet(void *p);

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

namespace ROOT {
   void TEveStraightLineSetEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveStraightLineSetEditor(void *p = 0);
   static void *newArray_TEveStraightLineSetEditor(Long_t size, void *p);
   static void delete_TEveStraightLineSetEditor(void *p);
   static void deleteArray_TEveStraightLineSetEditor(void *p);
   static void destruct_TEveStraightLineSetEditor(void *p);

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

namespace ROOT {
   void TEveStraightLineSetGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveStraightLineSetGL(void *p = 0);
   static void *newArray_TEveStraightLineSetGL(Long_t size, void *p);
   static void delete_TEveStraightLineSetGL(void *p);
   static void deleteArray_TEveStraightLineSetGL(void *p);
   static void destruct_TEveStraightLineSetGL(void *p);

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

namespace ROOT {
   void TEveText_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveText(void *p = 0);
   static void *newArray_TEveText(Long_t size, void *p);
   static void delete_TEveText(void *p);
   static void deleteArray_TEveText(void *p);
   static void destruct_TEveText(void *p);

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

namespace ROOT {
   void TEveTextEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveTextEditor(void *p = 0);
   static void *newArray_TEveTextEditor(Long_t size, void *p);
   static void delete_TEveTextEditor(void *p);
   static void deleteArray_TEveTextEditor(void *p);
   static void destruct_TEveTextEditor(void *p);

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

namespace ROOT {
   void TEveTextGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveTextGL(void *p = 0);
   static void *newArray_TEveTextGL(Long_t size, void *p);
   static void delete_TEveTextGL(void *p);
   static void deleteArray_TEveTextGL(void *p);
   static void destruct_TEveTextGL(void *p);

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

namespace ROOT {
   void TEveTrackPropagatorSubEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveTrackPropagatorSubEditor(void *p);
   static void deleteArray_TEveTrackPropagatorSubEditor(void *p);
   static void destruct_TEveTrackPropagatorSubEditor(void *p);

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

namespace ROOT {
   void TEveTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveTrack(void *p = 0);
   static void *newArray_TEveTrack(Long_t size, void *p);
   static void delete_TEveTrack(void *p);
   static void deleteArray_TEveTrack(void *p);
   static void destruct_TEveTrack(void *p);

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

namespace ROOT {
   void TEveTrackList_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveTrackList(void *p = 0);
   static void *newArray_TEveTrackList(Long_t size, void *p);
   static void delete_TEveTrackList(void *p);
   static void deleteArray_TEveTrackList(void *p);
   static void destruct_TEveTrackList(void *p);

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

namespace ROOT {
   void TEveTrackEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveTrackEditor(void *p = 0);
   static void *newArray_TEveTrackEditor(Long_t size, void *p);
   static void delete_TEveTrackEditor(void *p);
   static void deleteArray_TEveTrackEditor(void *p);
   static void destruct_TEveTrackEditor(void *p);

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

namespace ROOT {
   void TEveTrackListEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveTrackListEditor(void *p = 0);
   static void *newArray_TEveTrackListEditor(Long_t size, void *p);
   static void delete_TEveTrackListEditor(void *p);
   static void deleteArray_TEveTrackListEditor(void *p);
   static void destruct_TEveTrackListEditor(void *p);

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

namespace ROOT {
   void TEveTrackGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveTrackGL(void *p = 0);
   static void *newArray_TEveTrackGL(Long_t size, void *p);
   static void delete_TEveTrackGL(void *p);
   static void deleteArray_TEveTrackGL(void *p);
   static void destruct_TEveTrackGL(void *p);

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

namespace ROOT {
   void TEveTrackPropagator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveTrackPropagator(void *p = 0);
   static void *newArray_TEveTrackPropagator(Long_t size, void *p);
   static void delete_TEveTrackPropagator(void *p);
   static void deleteArray_TEveTrackPropagator(void *p);
   static void destruct_TEveTrackPropagator(void *p);

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

namespace ROOT {
   void TEveTrackProjected_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveTrackProjected(void *p = 0);
   static void *newArray_TEveTrackProjected(Long_t size, void *p);
   static void delete_TEveTrackProjected(void *p);
   static void deleteArray_TEveTrackProjected(void *p);
   static void destruct_TEveTrackProjected(void *p);

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

namespace ROOT {
   void TEveTrackProjectedGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveTrackProjectedGL(void *p = 0);
   static void *newArray_TEveTrackProjectedGL(Long_t size, void *p);
   static void delete_TEveTrackProjectedGL(void *p);
   static void deleteArray_TEveTrackProjectedGL(void *p);
   static void destruct_TEveTrackProjectedGL(void *p);

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

namespace ROOT {
   void TEveTrackListProjected_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveTrackListProjected(void *p = 0);
   static void *newArray_TEveTrackListProjected(Long_t size, void *p);
   static void delete_TEveTrackListProjected(void *p);
   static void deleteArray_TEveTrackListProjected(void *p);
   static void destruct_TEveTrackListProjected(void *p);

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

namespace ROOT {
   void TEveTrackPropagatorEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveTrackPropagatorEditor(void *p = 0);
   static void *newArray_TEveTrackPropagatorEditor(Long_t size, void *p);
   static void delete_TEveTrackPropagatorEditor(void *p);
   static void deleteArray_TEveTrackPropagatorEditor(void *p);
   static void destruct_TEveTrackPropagatorEditor(void *p);

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

namespace ROOT {
   void TEveMagField_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveMagField(void *p);
   static void deleteArray_TEveMagField(void *p);
   static void destruct_TEveMagField(void *p);

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

namespace ROOT {
   void TEveMagFieldConst_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveMagFieldConst(void *p);
   static void deleteArray_TEveMagFieldConst(void *p);
   static void destruct_TEveMagFieldConst(void *p);

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

namespace ROOT {
   void TEveMagFieldDuo_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveMagFieldDuo(void *p);
   static void deleteArray_TEveMagFieldDuo(void *p);
   static void destruct_TEveMagFieldDuo(void *p);

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

namespace ROOT {
   void TEveTriangleSet_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TEveTriangleSet(void *p);
   static void deleteArray_TEveTriangleSet(void *p);
   static void destruct_TEveTriangleSet(void *p);

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

namespace ROOT {
   void TEveTriangleSetEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveTriangleSetEditor(void *p = 0);
   static void *newArray_TEveTriangleSetEditor(Long_t size, void *p);
   static void delete_TEveTriangleSetEditor(void *p);
   static void deleteArray_TEveTriangleSetEditor(void *p);
   static void destruct_TEveTriangleSetEditor(void *p);

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

namespace ROOT {
   void TEveTriangleSetGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveTriangleSetGL(void *p = 0);
   static void *newArray_TEveTriangleSetGL(Long_t size, void *p);
   static void delete_TEveTriangleSetGL(void *p);
   static void deleteArray_TEveTriangleSetGL(void *p);
   static void destruct_TEveTriangleSetGL(void *p);

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

namespace ROOT {
   void TEveJetCone_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveJetCone(void *p = 0);
   static void *newArray_TEveJetCone(Long_t size, void *p);
   static void delete_TEveJetCone(void *p);
   static void deleteArray_TEveJetCone(void *p);
   static void destruct_TEveJetCone(void *p);

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

namespace ROOT {
   void TEveJetConeEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveJetConeEditor(void *p = 0);
   static void *newArray_TEveJetConeEditor(Long_t size, void *p);
   static void delete_TEveJetConeEditor(void *p);
   static void deleteArray_TEveJetConeEditor(void *p);
   static void destruct_TEveJetConeEditor(void *p);

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

namespace ROOT {
   void TEveJetConeProjected_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveJetConeProjected(void *p = 0);
   static void *newArray_TEveJetConeProjected(Long_t size, void *p);
   static void delete_TEveJetConeProjected(void *p);
   static void deleteArray_TEveJetConeProjected(void *p);
   static void destruct_TEveJetConeProjected(void *p);

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

namespace ROOT {
   void TEveJetConeGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveJetConeGL(void *p = 0);
   static void *newArray_TEveJetConeGL(Long_t size, void *p);
   static void delete_TEveJetConeGL(void *p);
   static void deleteArray_TEveJetConeGL(void *p);
   static void destruct_TEveJetConeGL(void *p);

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

namespace ROOT {
   void TEveJetConeProjectedGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEveJetConeProjectedGL(void *p = 0);
   static void *newArray_TEveJetConeProjectedGL(Long_t size, void *p);
   static void delete_TEveJetConeProjectedGL(void *p);
   static void deleteArray_TEveJetConeProjectedGL(void *p);
   static void destruct_TEveJetConeProjectedGL(void *p);

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

namespace ROOT {
   void TEvePlot3D_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvePlot3D(void *p = 0);
   static void *newArray_TEvePlot3D(Long_t size, void *p);
   static void delete_TEvePlot3D(void *p);
   static void deleteArray_TEvePlot3D(void *p);
   static void destruct_TEvePlot3D(void *p);

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

namespace ROOT {
   void TEvePlot3DGL_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TEvePlot3DGL(void *p = 0);
   static void *newArray_TEvePlot3DGL(Long_t size, void *p);
   static void delete_TEvePlot3DGL(void *p);
   static void deleteArray_TEvePlot3DGL(void *p);
   static void destruct_TEvePlot3DGL(void *p);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//______________________________________________________________________________
void TEveTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveTrack.
      TClass *R__cl = ::TEveTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      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(), "fPEnd", &fPEnd);
      R__insp.InspectMember(fPEnd, "fPEnd.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBeta", &fBeta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPdg", &fPdg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCharge", &fCharge);
      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(), "fLockPoints", &fLockPoints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPathMarks", (void*)&fPathMarks);
      R__insp.InspectMember("TEveTrack::vPathMark_t", (void*)&fPathMarks, "fPathMarks.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastPMIdx", &fLastPMIdx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPropagator", &fPropagator);
      TEveLine::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveTrack(void *p) {
      return  p ? new(p) ::TEveTrack : new ::TEveTrack;
   }
   static void *newArray_TEveTrack(Long_t nElements, void *p) {
      return p ? new(p) ::TEveTrack[nElements] : new ::TEveTrack[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveTrack(void *p) {
      delete ((::TEveTrack*)p);
   }
   static void deleteArray_TEveTrack(void *p) {
      delete [] ((::TEveTrack*)p);
   }
   static void destruct_TEveTrack(void *p) {
      typedef ::TEveTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTrack

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveTrackGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveTrackGL : new ::TEveTrackGL;
   }
   static void *newArray_TEveTrackGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveTrackGL[nElements] : new ::TEveTrackGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveTrackGL(void *p) {
      delete ((::TEveTrackGL*)p);
   }
   static void deleteArray_TEveTrackGL(void *p) {
      delete [] ((::TEveTrackGL*)p);
   }
   static void destruct_TEveTrackGL(void *p) {
      typedef ::TEveTrackGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTrackGL

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveTrackEditor(void *p) {
      return  p ? new(p) ::TEveTrackEditor : new ::TEveTrackEditor;
   }
   static void *newArray_TEveTrackEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveTrackEditor[nElements] : new ::TEveTrackEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveTrackEditor(void *p) {
      delete ((::TEveTrackEditor*)p);
   }
   static void deleteArray_TEveTrackEditor(void *p) {
      delete [] ((::TEveTrackEditor*)p);
   }
   static void destruct_TEveTrackEditor(void *p) {
      typedef ::TEveTrackEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTrackEditor

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

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

//______________________________________________________________________________
void TEveTrackList::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveTrackList.
      TClass *R__cl = ::TEveTrackList::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPropagator", &fPropagator);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRecurse", &fRecurse);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRnrLine", &fRnrLine);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRnrPoints", &fRnrPoints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinPt", &fMinPt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxPt", &fMaxPt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLimPt", &fLimPt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinP", &fMinP);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxP", &fMaxP);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLimP", &fLimP);
      TEveElementList::ShowMembers(R__insp);
      TAttMarker::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveTrackList(void *p) {
      return  p ? new(p) ::TEveTrackList : new ::TEveTrackList;
   }
   static void *newArray_TEveTrackList(Long_t nElements, void *p) {
      return p ? new(p) ::TEveTrackList[nElements] : new ::TEveTrackList[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveTrackList(void *p) {
      delete ((::TEveTrackList*)p);
   }
   static void deleteArray_TEveTrackList(void *p) {
      delete [] ((::TEveTrackList*)p);
   }
   static void destruct_TEveTrackList(void *p) {
      typedef ::TEveTrackList current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTrackList

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

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

//______________________________________________________________________________
void TEveTrackListEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveTrackListEditor.
      TClass *R__cl = ::TEveTrackListEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRefs", &fRefs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTC", &fTC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRnrLine", &fRnrLine);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRnrPoints", &fRnrPoints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPtRange", &fPtRange);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPRange", &fPRange);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRSSubEditor", &fRSSubEditor);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveTrackListEditor(void *p) {
      return  p ? new(p) ::TEveTrackListEditor : new ::TEveTrackListEditor;
   }
   static void *newArray_TEveTrackListEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveTrackListEditor[nElements] : new ::TEveTrackListEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveTrackListEditor(void *p) {
      delete ((::TEveTrackListEditor*)p);
   }
   static void deleteArray_TEveTrackListEditor(void *p) {
      delete [] ((::TEveTrackListEditor*)p);
   }
   static void destruct_TEveTrackListEditor(void *p) {
      typedef ::TEveTrackListEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTrackListEditor

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

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

//______________________________________________________________________________
void TEveTrackProjected::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveTrackProjected.
      TClass *R__cl = ::TEveTrackProjected::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOrigPnts", &fOrigPnts);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBreakPoints", (void*)&fBreakPoints);
      R__insp.InspectMember("vector<Int_t>", (void*)&fBreakPoints, "fBreakPoints.", false);
      TEveTrack::ShowMembers(R__insp);
      TEveProjected::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveTrackProjected(void *p) {
      return  p ? new(p) ::TEveTrackProjected : new ::TEveTrackProjected;
   }
   static void *newArray_TEveTrackProjected(Long_t nElements, void *p) {
      return p ? new(p) ::TEveTrackProjected[nElements] : new ::TEveTrackProjected[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveTrackProjected(void *p) {
      delete ((::TEveTrackProjected*)p);
   }
   static void deleteArray_TEveTrackProjected(void *p) {
      delete [] ((::TEveTrackProjected*)p);
   }
   static void destruct_TEveTrackProjected(void *p) {
      typedef ::TEveTrackProjected current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTrackProjected

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveTrackProjectedGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveTrackProjectedGL : new ::TEveTrackProjectedGL;
   }
   static void *newArray_TEveTrackProjectedGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveTrackProjectedGL[nElements] : new ::TEveTrackProjectedGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveTrackProjectedGL(void *p) {
      delete ((::TEveTrackProjectedGL*)p);
   }
   static void deleteArray_TEveTrackProjectedGL(void *p) {
      delete [] ((::TEveTrackProjectedGL*)p);
   }
   static void destruct_TEveTrackProjectedGL(void *p) {
      typedef ::TEveTrackProjectedGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTrackProjectedGL

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveTrackListProjected(void *p) {
      return  p ? new(p) ::TEveTrackListProjected : new ::TEveTrackListProjected;
   }
   static void *newArray_TEveTrackListProjected(Long_t nElements, void *p) {
      return p ? new(p) ::TEveTrackListProjected[nElements] : new ::TEveTrackListProjected[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveTrackListProjected(void *p) {
      delete ((::TEveTrackListProjected*)p);
   }
   static void deleteArray_TEveTrackListProjected(void *p) {
      delete [] ((::TEveTrackListProjected*)p);
   }
   static void destruct_TEveTrackListProjected(void *p) {
      typedef ::TEveTrackListProjected current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTrackListProjected

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

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

//______________________________________________________________________________
void TEveTrackPropagator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveTrackPropagator.
      TClass *R__cl = ::TEveTrackPropagator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStepper", &fStepper);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMagFieldObj", &fMagFieldObj);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnMagFiledObj", &fOwnMagFiledObj);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxR", &fMaxR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxZ", &fMaxZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNMax", &fNMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxOrbs", &fMaxOrbs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEditPathMarks", &fEditPathMarks);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitDaughters", &fFitDaughters);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitReferences", &fFitReferences);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitDecay", &fFitDecay);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitCluster2Ds", &fFitCluster2Ds);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRnrDaughters", &fRnrDaughters);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRnrReferences", &fRnrReferences);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRnrDecay", &fRnrDecay);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRnrCluster2Ds", &fRnrCluster2Ds);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRnrFV", &fRnrFV);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPMAtt", &fPMAtt);
      R__insp.InspectMember(fPMAtt, "fPMAtt.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFVAtt", &fFVAtt);
      R__insp.InspectMember(fFVAtt, "fFVAtt.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProjTrackBreaking", &fProjTrackBreaking);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRnrPTBMarkers", &fRnrPTBMarkers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPTBAtt", &fPTBAtt);
      R__insp.InspectMember(fPTBAtt, "fPTBAtt.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPoints", (void*)&fPoints);
      R__insp.InspectMember("vector<TEveVector4>", (void*)&fPoints, "fPoints.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fV", &fV);
      R__insp.InspectMember(fV, "fV.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fH", (void*)&fH);
      R__insp.InspectMember("TEveTrackPropagator::Helix_t", (void*)&fH, "fH.", false);
      TEveElementList::ShowMembers(R__insp);
      TEveRefBackPtr::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveTrackPropagator(void *p) {
      return  p ? new(p) ::TEveTrackPropagator : new ::TEveTrackPropagator;
   }
   static void *newArray_TEveTrackPropagator(Long_t nElements, void *p) {
      return p ? new(p) ::TEveTrackPropagator[nElements] : new ::TEveTrackPropagator[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveTrackPropagator(void *p) {
      delete ((::TEveTrackPropagator*)p);
   }
   static void deleteArray_TEveTrackPropagator(void *p) {
      delete [] ((::TEveTrackPropagator*)p);
   }
   static void destruct_TEveTrackPropagator(void *p) {
      typedef ::TEveTrackPropagator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTrackPropagator

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

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

//______________________________________________________________________________
void TEveTrackPropagatorSubEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveTrackPropagatorSubEditor.
      TClass *R__cl = ::TEveTrackPropagatorSubEditor::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(), "*fMaxR", &fMaxR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaxZ", &fMaxZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaxOrbits", &fMaxOrbits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaxAng", &fMaxAng);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelta", &fDelta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRefsCont", &fRefsCont);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPMFrame", &fPMFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFitDaughters", &fFitDaughters);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFitReferences", &fFitReferences);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFitDecay", &fFitDecay);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFitCluster2Ds", &fFitCluster2Ds);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRnrDaughters", &fRnrDaughters);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRnrReferences", &fRnrReferences);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRnrDecay", &fRnrDecay);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRnrCluster2Ds", &fRnrCluster2Ds);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRnrFV", &fRnrFV);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPMAtt", &fPMAtt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFVAtt", &fFVAtt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProjTrackBreaking", &fProjTrackBreaking);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRnrPTBMarkers", &fRnrPTBMarkers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPTBAtt", &fPTBAtt);
      TGVerticalFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveTrackPropagatorSubEditor(void *p) {
      delete ((::TEveTrackPropagatorSubEditor*)p);
   }
   static void deleteArray_TEveTrackPropagatorSubEditor(void *p) {
      delete [] ((::TEveTrackPropagatorSubEditor*)p);
   }
   static void destruct_TEveTrackPropagatorSubEditor(void *p) {
      typedef ::TEveTrackPropagatorSubEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTrackPropagatorSubEditor

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveTrackPropagatorEditor(void *p) {
      return  p ? new(p) ::TEveTrackPropagatorEditor : new ::TEveTrackPropagatorEditor;
   }
   static void *newArray_TEveTrackPropagatorEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveTrackPropagatorEditor[nElements] : new ::TEveTrackPropagatorEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveTrackPropagatorEditor(void *p) {
      delete ((::TEveTrackPropagatorEditor*)p);
   }
   static void deleteArray_TEveTrackPropagatorEditor(void *p) {
      delete [] ((::TEveTrackPropagatorEditor*)p);
   }
   static void destruct_TEveTrackPropagatorEditor(void *p) {
      typedef ::TEveTrackPropagatorEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTrackPropagatorEditor

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveMagField(void *p) {
      delete ((::TEveMagField*)p);
   }
   static void deleteArray_TEveMagField(void *p) {
      delete [] ((::TEveMagField*)p);
   }
   static void destruct_TEveMagField(void *p) {
      typedef ::TEveMagField current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveMagField

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveMagFieldConst(void *p) {
      delete ((::TEveMagFieldConst*)p);
   }
   static void deleteArray_TEveMagFieldConst(void *p) {
      delete [] ((::TEveMagFieldConst*)p);
   }
   static void destruct_TEveMagFieldConst(void *p) {
      typedef ::TEveMagFieldConst current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveMagFieldConst

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveMagFieldDuo(void *p) {
      delete ((::TEveMagFieldDuo*)p);
   }
   static void deleteArray_TEveMagFieldDuo(void *p) {
      delete [] ((::TEveMagFieldDuo*)p);
   }
   static void destruct_TEveMagFieldDuo(void *p) {
      typedef ::TEveMagFieldDuo current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveMagFieldDuo

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

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

//______________________________________________________________________________
void TEveText::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveText.
      TClass *R__cl = ::TEveText::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fText", &fText);
      R__insp.InspectMember(fText, "fText.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTextColor", &fTextColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontSize", &fFontSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontFile", &fFontFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontMode", &fFontMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExtrude", &fExtrude);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAutoLighting", &fAutoLighting);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLighting", &fLighting);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPolygonOffset[2]", fPolygonOffset);
      TEveElement::ShowMembers(R__insp);
      TNamed::ShowMembers(R__insp);
      TAtt3D::ShowMembers(R__insp);
      TAttBBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveText(void *p) {
      return  p ? new(p) ::TEveText : new ::TEveText;
   }
   static void *newArray_TEveText(Long_t nElements, void *p) {
      return p ? new(p) ::TEveText[nElements] : new ::TEveText[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveText(void *p) {
      delete ((::TEveText*)p);
   }
   static void deleteArray_TEveText(void *p) {
      delete [] ((::TEveText*)p);
   }
   static void destruct_TEveText(void *p) {
      typedef ::TEveText current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveText

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

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

//______________________________________________________________________________
void TEveTextGL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveTextGL.
      TClass *R__cl = ::TEveTextGL::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(), "fFont", &fFont);
      R__insp.InspectMember(fFont, "fFont.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX[4][3]", fX);
      TGLObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveTextGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveTextGL : new ::TEveTextGL;
   }
   static void *newArray_TEveTextGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveTextGL[nElements] : new ::TEveTextGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveTextGL(void *p) {
      delete ((::TEveTextGL*)p);
   }
   static void deleteArray_TEveTextGL(void *p) {
      delete [] ((::TEveTextGL*)p);
   }
   static void destruct_TEveTextGL(void *p) {
      typedef ::TEveTextGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTextGL

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

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

//______________________________________________________________________________
void TEveTextEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveTextEditor.
      TClass *R__cl = ::TEveTextEditor::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(), "*fText", &fText);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSize", &fSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFile", &fFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMode", &fMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExtrude", &fExtrude);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLighting", &fLighting);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAutoLighting", &fAutoLighting);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveTextEditor(void *p) {
      return  p ? new(p) ::TEveTextEditor : new ::TEveTextEditor;
   }
   static void *newArray_TEveTextEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveTextEditor[nElements] : new ::TEveTextEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveTextEditor(void *p) {
      delete ((::TEveTextEditor*)p);
   }
   static void deleteArray_TEveTextEditor(void *p) {
      delete [] ((::TEveTextEditor*)p);
   }
   static void destruct_TEveTextEditor(void *p) {
      typedef ::TEveTextEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTextEditor

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

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

//______________________________________________________________________________
void TEvePointSet::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEvePointSet.
      TClass *R__cl = ::TEvePointSet::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitle", &fTitle);
      R__insp.InspectMember(fTitle, "fTitle.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIntIds", &fIntIds);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIntIdsPerPoint", &fIntIdsPerPoint);
      TEveElement::ShowMembers(R__insp);
      TPointSet3D::ShowMembers(R__insp);
      TEvePointSelectorConsumer::ShowMembers(R__insp);
      TEveProjectable::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvePointSet(void *p) {
      return  p ? new(p) ::TEvePointSet : new ::TEvePointSet;
   }
   static void *newArray_TEvePointSet(Long_t nElements, void *p) {
      return p ? new(p) ::TEvePointSet[nElements] : new ::TEvePointSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvePointSet(void *p) {
      delete ((::TEvePointSet*)p);
   }
   static void deleteArray_TEvePointSet(void *p) {
      delete [] ((::TEvePointSet*)p);
   }
   static void destruct_TEvePointSet(void *p) {
      typedef ::TEvePointSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvePointSet

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

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

//______________________________________________________________________________
void TEvePointSetArray::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEvePointSetArray.
      TClass *R__cl = ::TEvePointSetArray::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBins", &fBins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefPointSetCapacity", &fDefPointSetCapacity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNBins", &fNBins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastBin", &fLastBin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMin", &fMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurMin", &fCurMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMax", &fMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurMax", &fCurMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinWidth", &fBinWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQuantName", &fQuantName);
      R__insp.InspectMember(fQuantName, "fQuantName.");
      TEveElement::ShowMembers(R__insp);
      TNamed::ShowMembers(R__insp);
      TAttMarker::ShowMembers(R__insp);
      TEvePointSelectorConsumer::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvePointSetArray(void *p) {
      return  p ? new(p) ::TEvePointSetArray : new ::TEvePointSetArray;
   }
   static void *newArray_TEvePointSetArray(Long_t nElements, void *p) {
      return p ? new(p) ::TEvePointSetArray[nElements] : new ::TEvePointSetArray[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvePointSetArray(void *p) {
      delete ((::TEvePointSetArray*)p);
   }
   static void deleteArray_TEvePointSetArray(void *p) {
      delete [] ((::TEvePointSetArray*)p);
   }
   static void destruct_TEvePointSetArray(void *p) {
      typedef ::TEvePointSetArray current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvePointSetArray

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvePointSetArrayEditor(void *p) {
      return  p ? new(p) ::TEvePointSetArrayEditor : new ::TEvePointSetArrayEditor;
   }
   static void *newArray_TEvePointSetArrayEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEvePointSetArrayEditor[nElements] : new ::TEvePointSetArrayEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvePointSetArrayEditor(void *p) {
      delete ((::TEvePointSetArrayEditor*)p);
   }
   static void deleteArray_TEvePointSetArrayEditor(void *p) {
      delete [] ((::TEvePointSetArrayEditor*)p);
   }
   static void destruct_TEvePointSetArrayEditor(void *p) {
      typedef ::TEvePointSetArrayEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvePointSetArrayEditor

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvePointSetProjected(void *p) {
      return  p ? new(p) ::TEvePointSetProjected : new ::TEvePointSetProjected;
   }
   static void *newArray_TEvePointSetProjected(Long_t nElements, void *p) {
      return p ? new(p) ::TEvePointSetProjected[nElements] : new ::TEvePointSetProjected[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvePointSetProjected(void *p) {
      delete ((::TEvePointSetProjected*)p);
   }
   static void deleteArray_TEvePointSetProjected(void *p) {
      delete [] ((::TEvePointSetProjected*)p);
   }
   static void destruct_TEvePointSetProjected(void *p) {
      typedef ::TEvePointSetProjected current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvePointSetProjected

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveLine(void *p) {
      return  p ? new(p) ::TEveLine : new ::TEveLine;
   }
   static void *newArray_TEveLine(Long_t nElements, void *p) {
      return p ? new(p) ::TEveLine[nElements] : new ::TEveLine[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveLine(void *p) {
      delete ((::TEveLine*)p);
   }
   static void deleteArray_TEveLine(void *p) {
      delete [] ((::TEveLine*)p);
   }
   static void destruct_TEveLine(void *p) {
      typedef ::TEveLine current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveLine

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveLineEditor(void *p) {
      return  p ? new(p) ::TEveLineEditor : new ::TEveLineEditor;
   }
   static void *newArray_TEveLineEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveLineEditor[nElements] : new ::TEveLineEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveLineEditor(void *p) {
      delete ((::TEveLineEditor*)p);
   }
   static void deleteArray_TEveLineEditor(void *p) {
      delete [] ((::TEveLineEditor*)p);
   }
   static void destruct_TEveLineEditor(void *p) {
      typedef ::TEveLineEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveLineEditor

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveLineGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveLineGL : new ::TEveLineGL;
   }
   static void *newArray_TEveLineGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveLineGL[nElements] : new ::TEveLineGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveLineGL(void *p) {
      delete ((::TEveLineGL*)p);
   }
   static void deleteArray_TEveLineGL(void *p) {
      delete [] ((::TEveLineGL*)p);
   }
   static void destruct_TEveLineGL(void *p) {
      typedef ::TEveLineGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveLineGL

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveLineProjected(void *p) {
      return  p ? new(p) ::TEveLineProjected : new ::TEveLineProjected;
   }
   static void *newArray_TEveLineProjected(Long_t nElements, void *p) {
      return p ? new(p) ::TEveLineProjected[nElements] : new ::TEveLineProjected[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveLineProjected(void *p) {
      delete ((::TEveLineProjected*)p);
   }
   static void deleteArray_TEveLineProjected(void *p) {
      delete [] ((::TEveLineProjected*)p);
   }
   static void destruct_TEveLineProjected(void *p) {
      typedef ::TEveLineProjected current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveLineProjected

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

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

//______________________________________________________________________________
void TEveArrow::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveArrow.
      TClass *R__cl = ::TEveArrow::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(), "fTubeR", &fTubeR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConeR", &fConeR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConeL", &fConeL);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrigin", &fOrigin);
      R__insp.InspectMember(fOrigin, "fOrigin.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVector", &fVector);
      R__insp.InspectMember(fVector, "fVector.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawQuality", &fDrawQuality);
      TEveElement::ShowMembers(R__insp);
      TNamed::ShowMembers(R__insp);
      TAtt3D::ShowMembers(R__insp);
      TAttBBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveArrow(void *p) {
      return  p ? new(p) ::TEveArrow : new ::TEveArrow;
   }
   static void *newArray_TEveArrow(Long_t nElements, void *p) {
      return p ? new(p) ::TEveArrow[nElements] : new ::TEveArrow[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveArrow(void *p) {
      delete ((::TEveArrow*)p);
   }
   static void deleteArray_TEveArrow(void *p) {
      delete [] ((::TEveArrow*)p);
   }
   static void destruct_TEveArrow(void *p) {
      typedef ::TEveArrow current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveArrow

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

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

//______________________________________________________________________________
void TEveArrowEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveArrowEditor.
      TClass *R__cl = ::TEveArrowEditor::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(), "*fTubeR", &fTubeR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fConeR", &fConeR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fConeL", &fConeL);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOrigin", &fOrigin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVector", &fVector);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveArrowEditor(void *p) {
      return  p ? new(p) ::TEveArrowEditor : new ::TEveArrowEditor;
   }
   static void *newArray_TEveArrowEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveArrowEditor[nElements] : new ::TEveArrowEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveArrowEditor(void *p) {
      delete ((::TEveArrowEditor*)p);
   }
   static void deleteArray_TEveArrowEditor(void *p) {
      delete [] ((::TEveArrowEditor*)p);
   }
   static void destruct_TEveArrowEditor(void *p) {
      typedef ::TEveArrowEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveArrowEditor

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveArrowGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveArrowGL : new ::TEveArrowGL;
   }
   static void *newArray_TEveArrowGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveArrowGL[nElements] : new ::TEveArrowGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveArrowGL(void *p) {
      delete ((::TEveArrowGL*)p);
   }
   static void deleteArray_TEveArrowGL(void *p) {
      delete [] ((::TEveArrowGL*)p);
   }
   static void destruct_TEveArrowGL(void *p) {
      typedef ::TEveArrowGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveArrowGL

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

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

//______________________________________________________________________________
void TEveDigitSet::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveDigitSet.
      TClass *R__cl = ::TEveDigitSet::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDigitIds", &fDigitIds);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultValue", &fDefaultValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValueIsColor", &fValueIsColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSingleColor", &fSingleColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAntiFlick", &fAntiFlick);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnIds", &fOwnIds);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPlex", &fPlex);
      R__insp.InspectMember(fPlex, "fPlex.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLastDigit", &fLastDigit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastIdx", &fLastIdx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColor", &fColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrame", &fFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPalette", &fPalette);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRenderMode", &fRenderMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDisableLighting", &fDisableLighting);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistoButtons", &fHistoButtons);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEmitSignals", &fEmitSignals);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCallbackFoo", &fCallbackFoo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTooltipCBFoo", &fTooltipCBFoo);
      TEveElement::ShowMembers(R__insp);
      TNamed::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
      TAtt3D::ShowMembers(R__insp);
      TAttBBox::ShowMembers(R__insp);
      TEveSecondarySelectable::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveDigitSet(void *p) {
      delete ((::TEveDigitSet*)p);
   }
   static void deleteArray_TEveDigitSet(void *p) {
      delete [] ((::TEveDigitSet*)p);
   }
   static void destruct_TEveDigitSet(void *p) {
      typedef ::TEveDigitSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveDigitSet

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveDigitSetEditor(void *p) {
      return  p ? new(p) ::TEveDigitSetEditor : new ::TEveDigitSetEditor;
   }
   static void *newArray_TEveDigitSetEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveDigitSetEditor[nElements] : new ::TEveDigitSetEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveDigitSetEditor(void *p) {
      delete ((::TEveDigitSetEditor*)p);
   }
   static void deleteArray_TEveDigitSetEditor(void *p) {
      delete [] ((::TEveDigitSetEditor*)p);
   }
   static void destruct_TEveDigitSetEditor(void *p) {
      typedef ::TEveDigitSetEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveDigitSetEditor

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveDigitSetGL(void *p) {
      delete ((::TEveDigitSetGL*)p);
   }
   static void deleteArray_TEveDigitSetGL(void *p) {
      delete [] ((::TEveDigitSetGL*)p);
   }
   static void destruct_TEveDigitSetGL(void *p) {
      typedef ::TEveDigitSetGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveDigitSetGL

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveQuadSet(void *p) {
      return  p ? new(p) ::TEveQuadSet : new ::TEveQuadSet;
   }
   static void *newArray_TEveQuadSet(Long_t nElements, void *p) {
      return p ? new(p) ::TEveQuadSet[nElements] : new ::TEveQuadSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveQuadSet(void *p) {
      delete ((::TEveQuadSet*)p);
   }
   static void deleteArray_TEveQuadSet(void *p) {
      delete [] ((::TEveQuadSet*)p);
   }
   static void destruct_TEveQuadSet(void *p) {
      typedef ::TEveQuadSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveQuadSet

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveQuadSetGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveQuadSetGL : new ::TEveQuadSetGL;
   }
   static void *newArray_TEveQuadSetGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveQuadSetGL[nElements] : new ::TEveQuadSetGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveQuadSetGL(void *p) {
      delete ((::TEveQuadSetGL*)p);
   }
   static void deleteArray_TEveQuadSetGL(void *p) {
      delete [] ((::TEveQuadSetGL*)p);
   }
   static void destruct_TEveQuadSetGL(void *p) {
      typedef ::TEveQuadSetGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveQuadSetGL

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveBoxSet(void *p) {
      return  p ? new(p) ::TEveBoxSet : new ::TEveBoxSet;
   }
   static void *newArray_TEveBoxSet(Long_t nElements, void *p) {
      return p ? new(p) ::TEveBoxSet[nElements] : new ::TEveBoxSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveBoxSet(void *p) {
      delete ((::TEveBoxSet*)p);
   }
   static void deleteArray_TEveBoxSet(void *p) {
      delete [] ((::TEveBoxSet*)p);
   }
   static void destruct_TEveBoxSet(void *p) {
      typedef ::TEveBoxSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveBoxSet

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveBoxSetGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveBoxSetGL : new ::TEveBoxSetGL;
   }
   static void *newArray_TEveBoxSetGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveBoxSetGL[nElements] : new ::TEveBoxSetGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveBoxSetGL(void *p) {
      delete ((::TEveBoxSetGL*)p);
   }
   static void deleteArray_TEveBoxSetGL(void *p) {
      delete [] ((::TEveBoxSetGL*)p);
   }
   static void destruct_TEveBoxSetGL(void *p) {
      typedef ::TEveBoxSetGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveBoxSetGL

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveGeoNode(void *p) {
      delete ((::TEveGeoNode*)p);
   }
   static void deleteArray_TEveGeoNode(void *p) {
      delete [] ((::TEveGeoNode*)p);
   }
   static void destruct_TEveGeoNode(void *p) {
      typedef ::TEveGeoNode current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGeoNode

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveGeoTopNode(void *p) {
      delete ((::TEveGeoTopNode*)p);
   }
   static void deleteArray_TEveGeoTopNode(void *p) {
      delete [] ((::TEveGeoTopNode*)p);
   }
   static void destruct_TEveGeoTopNode(void *p) {
      typedef ::TEveGeoTopNode current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGeoTopNode

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveGeoNodeEditor(void *p) {
      return  p ? new(p) ::TEveGeoNodeEditor : new ::TEveGeoNodeEditor;
   }
   static void *newArray_TEveGeoNodeEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveGeoNodeEditor[nElements] : new ::TEveGeoNodeEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveGeoNodeEditor(void *p) {
      delete ((::TEveGeoNodeEditor*)p);
   }
   static void deleteArray_TEveGeoNodeEditor(void *p) {
      delete [] ((::TEveGeoNodeEditor*)p);
   }
   static void destruct_TEveGeoNodeEditor(void *p) {
      typedef ::TEveGeoNodeEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGeoNodeEditor

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveGeoTopNodeEditor(void *p) {
      return  p ? new(p) ::TEveGeoTopNodeEditor : new ::TEveGeoTopNodeEditor;
   }
   static void *newArray_TEveGeoTopNodeEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveGeoTopNodeEditor[nElements] : new ::TEveGeoTopNodeEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveGeoTopNodeEditor(void *p) {
      delete ((::TEveGeoTopNodeEditor*)p);
   }
   static void deleteArray_TEveGeoTopNodeEditor(void *p) {
      delete [] ((::TEveGeoTopNodeEditor*)p);
   }
   static void destruct_TEveGeoTopNodeEditor(void *p) {
      typedef ::TEveGeoTopNodeEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGeoTopNodeEditor

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveGeoShape(void *p) {
      return  p ? new(p) ::TEveGeoShape : new ::TEveGeoShape;
   }
   static void *newArray_TEveGeoShape(Long_t nElements, void *p) {
      return p ? new(p) ::TEveGeoShape[nElements] : new ::TEveGeoShape[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveGeoShape(void *p) {
      delete ((::TEveGeoShape*)p);
   }
   static void deleteArray_TEveGeoShape(void *p) {
      delete [] ((::TEveGeoShape*)p);
   }
   static void destruct_TEveGeoShape(void *p) {
      typedef ::TEveGeoShape current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGeoShape

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveGeoShapeProjected(void *p) {
      return  p ? new(p) ::TEveGeoShapeProjected : new ::TEveGeoShapeProjected;
   }
   static void *newArray_TEveGeoShapeProjected(Long_t nElements, void *p) {
      return p ? new(p) ::TEveGeoShapeProjected[nElements] : new ::TEveGeoShapeProjected[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveGeoShapeProjected(void *p) {
      delete ((::TEveGeoShapeProjected*)p);
   }
   static void deleteArray_TEveGeoShapeProjected(void *p) {
      delete [] ((::TEveGeoShapeProjected*)p);
   }
   static void destruct_TEveGeoShapeProjected(void *p) {
      typedef ::TEveGeoShapeProjected current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGeoShapeProjected

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

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

//______________________________________________________________________________
void TEveGeoShapeExtract::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveGeoShapeExtract.
      TClass *R__cl = ::TEveGeoShapeExtract::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrans[16]", fTrans);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRGBA[4]", fRGBA);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRGBALine[4]", fRGBALine);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRnrSelf", &fRnrSelf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRnrElements", &fRnrElements);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRnrFrame", &fRnrFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMiniFrame", &fMiniFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElements", &fElements);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveGeoShapeExtract(void *p) {
      return  p ? new(p) ::TEveGeoShapeExtract : new ::TEveGeoShapeExtract;
   }
   static void *newArray_TEveGeoShapeExtract(Long_t nElements, void *p) {
      return p ? new(p) ::TEveGeoShapeExtract[nElements] : new ::TEveGeoShapeExtract[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveGeoShapeExtract(void *p) {
      delete ((::TEveGeoShapeExtract*)p);
   }
   static void deleteArray_TEveGeoShapeExtract(void *p) {
      delete [] ((::TEveGeoShapeExtract*)p);
   }
   static void destruct_TEveGeoShapeExtract(void *p) {
      typedef ::TEveGeoShapeExtract current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGeoShapeExtract

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

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

//______________________________________________________________________________
void TEveGeoPolyShape::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveGeoPolyShape.
      TClass *R__cl = ::TEveGeoPolyShape::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVertices", (void*)&fVertices);
      R__insp.InspectMember("vector<Double_t>", (void*)&fVertices, "fVertices.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPolyDesc", (void*)&fPolyDesc);
      R__insp.InspectMember("vector<Int_t>", (void*)&fPolyDesc, "fPolyDesc.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbPols", &fNbPols);
      TGeoBBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveGeoPolyShape(void *p) {
      return  p ? new(p) ::TEveGeoPolyShape : new ::TEveGeoPolyShape;
   }
   static void *newArray_TEveGeoPolyShape(Long_t nElements, void *p) {
      return p ? new(p) ::TEveGeoPolyShape[nElements] : new ::TEveGeoPolyShape[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveGeoPolyShape(void *p) {
      delete ((::TEveGeoPolyShape*)p);
   }
   static void deleteArray_TEveGeoPolyShape(void *p) {
      delete [] ((::TEveGeoPolyShape*)p);
   }
   static void destruct_TEveGeoPolyShape(void *p) {
      typedef ::TEveGeoPolyShape current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGeoPolyShape

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

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

//______________________________________________________________________________
void TEveShape::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveShape.
      TClass *R__cl = ::TEveShape::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFillColor", &fFillColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLineColor", &fLineColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLineWidth", &fLineWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawFrame", &fDrawFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighlightFrame", &fHighlightFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMiniFrame", &fMiniFrame);
      TEveElementList::ShowMembers(R__insp);
      TAtt3D::ShowMembers(R__insp);
      TAttBBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveShape(void *p) {
      delete ((::TEveShape*)p);
   }
   static void deleteArray_TEveShape(void *p) {
      delete [] ((::TEveShape*)p);
   }
   static void destruct_TEveShape(void *p) {
      typedef ::TEveShape current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveShape

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveShapeEditor(void *p) {
      return  p ? new(p) ::TEveShapeEditor : new ::TEveShapeEditor;
   }
   static void *newArray_TEveShapeEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveShapeEditor[nElements] : new ::TEveShapeEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveShapeEditor(void *p) {
      delete ((::TEveShapeEditor*)p);
   }
   static void deleteArray_TEveShapeEditor(void *p) {
      delete [] ((::TEveShapeEditor*)p);
   }
   static void destruct_TEveShapeEditor(void *p) {
      typedef ::TEveShapeEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveShapeEditor

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveBox(void *p) {
      return  p ? new(p) ::TEveBox : new ::TEveBox;
   }
   static void *newArray_TEveBox(Long_t nElements, void *p) {
      return p ? new(p) ::TEveBox[nElements] : new ::TEveBox[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveBox(void *p) {
      delete ((::TEveBox*)p);
   }
   static void deleteArray_TEveBox(void *p) {
      delete [] ((::TEveBox*)p);
   }
   static void destruct_TEveBox(void *p) {
      typedef ::TEveBox current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveBox

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveBoxGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveBoxGL : new ::TEveBoxGL;
   }
   static void *newArray_TEveBoxGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveBoxGL[nElements] : new ::TEveBoxGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveBoxGL(void *p) {
      delete ((::TEveBoxGL*)p);
   }
   static void deleteArray_TEveBoxGL(void *p) {
      delete [] ((::TEveBoxGL*)p);
   }
   static void destruct_TEveBoxGL(void *p) {
      typedef ::TEveBoxGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveBoxGL

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

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

//______________________________________________________________________________
void TEveBoxProjected::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveBoxProjected.
      TClass *R__cl = ::TEveBoxProjected::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPoints", (void*)&fPoints);
      R__insp.InspectMember("TEveShape::vVector2_t", (void*)&fPoints, "fPoints.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBreakIdx", &fBreakIdx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDebugPoints", (void*)&fDebugPoints);
      R__insp.InspectMember("TEveShape::vVector2_t", (void*)&fDebugPoints, "fDebugPoints.", false);
      TEveShape::ShowMembers(R__insp);
      TEveProjected::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveBoxProjected(void *p) {
      return  p ? new(p) ::TEveBoxProjected : new ::TEveBoxProjected;
   }
   static void *newArray_TEveBoxProjected(Long_t nElements, void *p) {
      return p ? new(p) ::TEveBoxProjected[nElements] : new ::TEveBoxProjected[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveBoxProjected(void *p) {
      delete ((::TEveBoxProjected*)p);
   }
   static void deleteArray_TEveBoxProjected(void *p) {
      delete [] ((::TEveBoxProjected*)p);
   }
   static void destruct_TEveBoxProjected(void *p) {
      typedef ::TEveBoxProjected current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveBoxProjected

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveBoxProjectedGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveBoxProjectedGL : new ::TEveBoxProjectedGL;
   }
   static void *newArray_TEveBoxProjectedGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveBoxProjectedGL[nElements] : new ::TEveBoxProjectedGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveBoxProjectedGL(void *p) {
      delete ((::TEveBoxProjectedGL*)p);
   }
   static void deleteArray_TEveBoxProjectedGL(void *p) {
      delete [] ((::TEveBoxProjectedGL*)p);
   }
   static void destruct_TEveBoxProjectedGL(void *p) {
      typedef ::TEveBoxProjectedGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveBoxProjectedGL

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

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

//______________________________________________________________________________
void TEvePolygonSetProjected::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEvePolygonSetProjected.
      TClass *R__cl = ::TEvePolygonSetProjected::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBuff", &fBuff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPols", (void*)&fPols);
      R__insp.InspectMember("TEvePolygonSetProjected::vpPolygon_t", (void*)&fPols, "fPols.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPolsBS", (void*)&fPolsBS);
      R__insp.InspectMember("TEvePolygonSetProjected::vpPolygon_t", (void*)&fPolsBS, "fPolsBS.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPolsBP", (void*)&fPolsBP);
      R__insp.InspectMember("TEvePolygonSetProjected::vpPolygon_t", (void*)&fPolsBP, "fPolsBP.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNPnts", &fNPnts);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPnts", &fPnts);
      TEveShape::ShowMembers(R__insp);
      TEveProjected::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvePolygonSetProjected(void *p) {
      return  p ? new(p) ::TEvePolygonSetProjected : new ::TEvePolygonSetProjected;
   }
   static void *newArray_TEvePolygonSetProjected(Long_t nElements, void *p) {
      return p ? new(p) ::TEvePolygonSetProjected[nElements] : new ::TEvePolygonSetProjected[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvePolygonSetProjected(void *p) {
      delete ((::TEvePolygonSetProjected*)p);
   }
   static void deleteArray_TEvePolygonSetProjected(void *p) {
      delete [] ((::TEvePolygonSetProjected*)p);
   }
   static void destruct_TEvePolygonSetProjected(void *p) {
      typedef ::TEvePolygonSetProjected current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvePolygonSetProjected

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvePolygonSetProjectedGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEvePolygonSetProjectedGL : new ::TEvePolygonSetProjectedGL;
   }
   static void *newArray_TEvePolygonSetProjectedGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEvePolygonSetProjectedGL[nElements] : new ::TEvePolygonSetProjectedGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvePolygonSetProjectedGL(void *p) {
      delete ((::TEvePolygonSetProjectedGL*)p);
   }
   static void deleteArray_TEvePolygonSetProjectedGL(void *p) {
      delete [] ((::TEvePolygonSetProjectedGL*)p);
   }
   static void destruct_TEvePolygonSetProjectedGL(void *p) {
      typedef ::TEvePolygonSetProjectedGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvePolygonSetProjectedGL

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

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

//______________________________________________________________________________
void TEveTriangleSet::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveTriangleSet.
      TClass *R__cl = ::TEveTriangleSet::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNVerts", &fNVerts);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVerts", &fVerts);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTrings", &fNTrings);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrings", &fTrings);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTringNorms", &fTringNorms);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTringCols", &fTringCols);
      TEveElementList::ShowMembers(R__insp);
      TAtt3D::ShowMembers(R__insp);
      TAttBBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveTriangleSet(void *p) {
      delete ((::TEveTriangleSet*)p);
   }
   static void deleteArray_TEveTriangleSet(void *p) {
      delete [] ((::TEveTriangleSet*)p);
   }
   static void destruct_TEveTriangleSet(void *p) {
      typedef ::TEveTriangleSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTriangleSet

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveTriangleSetEditor(void *p) {
      return  p ? new(p) ::TEveTriangleSetEditor : new ::TEveTriangleSetEditor;
   }
   static void *newArray_TEveTriangleSetEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveTriangleSetEditor[nElements] : new ::TEveTriangleSetEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveTriangleSetEditor(void *p) {
      delete ((::TEveTriangleSetEditor*)p);
   }
   static void deleteArray_TEveTriangleSetEditor(void *p) {
      delete [] ((::TEveTriangleSetEditor*)p);
   }
   static void destruct_TEveTriangleSetEditor(void *p) {
      typedef ::TEveTriangleSetEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTriangleSetEditor

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveTriangleSetGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveTriangleSetGL : new ::TEveTriangleSetGL;
   }
   static void *newArray_TEveTriangleSetGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveTriangleSetGL[nElements] : new ::TEveTriangleSetGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveTriangleSetGL(void *p) {
      delete ((::TEveTriangleSetGL*)p);
   }
   static void deleteArray_TEveTriangleSetGL(void *p) {
      delete [] ((::TEveTriangleSetGL*)p);
   }
   static void destruct_TEveTriangleSetGL(void *p) {
      typedef ::TEveTriangleSetGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveTriangleSetGL

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

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

//______________________________________________________________________________
void TEveStraightLineSet::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveStraightLineSet.
      TClass *R__cl = ::TEveStraightLineSet::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLinePlex", &fLinePlex);
      R__insp.InspectMember(fLinePlex, "fLinePlex.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMarkerPlex", &fMarkerPlex);
      R__insp.InspectMember(fMarkerPlex, "fMarkerPlex.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnLinesIds", &fOwnLinesIds);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnMarkersIds", &fOwnMarkersIds);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRnrMarkers", &fRnrMarkers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRnrLines", &fRnrLines);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDepthTest", &fDepthTest);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLastLine", &fLastLine);
      TEveElement::ShowMembers(R__insp);
      TEveProjectable::ShowMembers(R__insp);
      TNamed::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
      TAtt3D::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
      TAttMarker::ShowMembers(R__insp);
      TAttBBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveStraightLineSet(void *p) {
      return  p ? new(p) ::TEveStraightLineSet : new ::TEveStraightLineSet;
   }
   static void *newArray_TEveStraightLineSet(Long_t nElements, void *p) {
      return p ? new(p) ::TEveStraightLineSet[nElements] : new ::TEveStraightLineSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveStraightLineSet(void *p) {
      delete ((::TEveStraightLineSet*)p);
   }
   static void deleteArray_TEveStraightLineSet(void *p) {
      delete [] ((::TEveStraightLineSet*)p);
   }
   static void destruct_TEveStraightLineSet(void *p) {
      typedef ::TEveStraightLineSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveStraightLineSet

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveStraightLineSetGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveStraightLineSetGL : new ::TEveStraightLineSetGL;
   }
   static void *newArray_TEveStraightLineSetGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveStraightLineSetGL[nElements] : new ::TEveStraightLineSetGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveStraightLineSetGL(void *p) {
      delete ((::TEveStraightLineSetGL*)p);
   }
   static void deleteArray_TEveStraightLineSetGL(void *p) {
      delete [] ((::TEveStraightLineSetGL*)p);
   }
   static void destruct_TEveStraightLineSetGL(void *p) {
      typedef ::TEveStraightLineSetGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveStraightLineSetGL

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveStraightLineSetEditor(void *p) {
      return  p ? new(p) ::TEveStraightLineSetEditor : new ::TEveStraightLineSetEditor;
   }
   static void *newArray_TEveStraightLineSetEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveStraightLineSetEditor[nElements] : new ::TEveStraightLineSetEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveStraightLineSetEditor(void *p) {
      delete ((::TEveStraightLineSetEditor*)p);
   }
   static void deleteArray_TEveStraightLineSetEditor(void *p) {
      delete [] ((::TEveStraightLineSetEditor*)p);
   }
   static void destruct_TEveStraightLineSetEditor(void *p) {
      typedef ::TEveStraightLineSetEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveStraightLineSetEditor

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveStraightLineSetProjected(void *p) {
      return  p ? new(p) ::TEveStraightLineSetProjected : new ::TEveStraightLineSetProjected;
   }
   static void *newArray_TEveStraightLineSetProjected(Long_t nElements, void *p) {
      return p ? new(p) ::TEveStraightLineSetProjected[nElements] : new ::TEveStraightLineSetProjected[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveStraightLineSetProjected(void *p) {
      delete ((::TEveStraightLineSetProjected*)p);
   }
   static void deleteArray_TEveStraightLineSetProjected(void *p) {
      delete [] ((::TEveStraightLineSetProjected*)p);
   }
   static void destruct_TEveStraightLineSetProjected(void *p) {
      typedef ::TEveStraightLineSetProjected current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveStraightLineSetProjected

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveScalableStraightLineSet(void *p) {
      return  p ? new(p) ::TEveScalableStraightLineSet : new ::TEveScalableStraightLineSet;
   }
   static void *newArray_TEveScalableStraightLineSet(Long_t nElements, void *p) {
      return p ? new(p) ::TEveScalableStraightLineSet[nElements] : new ::TEveScalableStraightLineSet[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveScalableStraightLineSet(void *p) {
      delete ((::TEveScalableStraightLineSet*)p);
   }
   static void deleteArray_TEveScalableStraightLineSet(void *p) {
      delete [] ((::TEveScalableStraightLineSet*)p);
   }
   static void destruct_TEveScalableStraightLineSet(void *p) {
      typedef ::TEveScalableStraightLineSet current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveScalableStraightLineSet

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

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

//______________________________________________________________________________
void TEveCaloData::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveCaloData.
      TClass *R__cl = ::TEveCaloData::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSliceInfos", (void*)&fSliceInfos);
      R__insp.InspectMember("TEveCaloData::vSliceInfo_t", (void*)&fSliceInfos, "fSliceInfos.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEtaAxis", &fEtaAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPhiAxis", &fPhiAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWrapTwoPi", &fWrapTwoPi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxValEt", &fMaxValEt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxValE", &fMaxValE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEps", &fEps);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCellsSelected", (void*)&fCellsSelected);
      R__insp.InspectMember("TEveCaloData::vCellId_t", (void*)&fCellsSelected, "fCellsSelected.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCellsHighlighted", (void*)&fCellsHighlighted);
      R__insp.InspectMember("TEveCaloData::vCellId_t", (void*)&fCellsHighlighted, "fCellsHighlighted.", false);
      TEveElement::ShowMembers(R__insp);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveCaloData(void *p) {
      delete ((::TEveCaloData*)p);
   }
   static void deleteArray_TEveCaloData(void *p) {
      delete [] ((::TEveCaloData*)p);
   }
   static void destruct_TEveCaloData(void *p) {
      typedef ::TEveCaloData current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCaloData

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveCaloDatacLcLSliceInfo_t(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveCaloData::SliceInfo_t : new ::TEveCaloData::SliceInfo_t;
   }
   static void *newArray_TEveCaloDatacLcLSliceInfo_t(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveCaloData::SliceInfo_t[nElements] : new ::TEveCaloData::SliceInfo_t[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveCaloDatacLcLSliceInfo_t(void *p) {
      delete ((::TEveCaloData::SliceInfo_t*)p);
   }
   static void deleteArray_TEveCaloDatacLcLSliceInfo_t(void *p) {
      delete [] ((::TEveCaloData::SliceInfo_t*)p);
   }
   static void destruct_TEveCaloDatacLcLSliceInfo_t(void *p) {
      typedef ::TEveCaloData::SliceInfo_t current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCaloData::SliceInfo_t

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

   TEveCaloData::Streamer(R__b);
}

//______________________________________________________________________________
void TEveCaloDataVec::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveCaloDataVec.
      TClass *R__cl = ::TEveCaloDataVec::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSliceVec", (void*)&fSliceVec);
      R__insp.InspectMember("TEveCaloDataVec::vvFloat_t", (void*)&fSliceVec, "fSliceVec.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGeomVec", (void*)&fGeomVec);
      R__insp.InspectMember("TEveCaloData::vCellGeom_t", (void*)&fGeomVec, "fGeomVec.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTower", &fTower);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEtaMin", &fEtaMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEtaMax", &fEtaMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiMin", &fPhiMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiMax", &fPhiMax);
      TEveCaloData::ShowMembers(R__insp);
}

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

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

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

//______________________________________________________________________________
void TEveCaloDataHist::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveCaloDataHist.
      TClass *R__cl = ::TEveCaloDataHist::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHStack", &fHStack);
      TEveCaloData::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveCaloDataHist(void *p) {
      return  p ? new(p) ::TEveCaloDataHist : new ::TEveCaloDataHist;
   }
   static void *newArray_TEveCaloDataHist(Long_t nElements, void *p) {
      return p ? new(p) ::TEveCaloDataHist[nElements] : new ::TEveCaloDataHist[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveCaloDataHist(void *p) {
      delete ((::TEveCaloDataHist*)p);
   }
   static void deleteArray_TEveCaloDataHist(void *p) {
      delete [] ((::TEveCaloDataHist*)p);
   }
   static void destruct_TEveCaloDataHist(void *p) {
      typedef ::TEveCaloDataHist current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCaloDataHist

//______________________________________________________________________________
void TEveCaloViz::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveCaloViz.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveCaloViz::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveCaloViz::Class(),this);
   }
}

//______________________________________________________________________________
void TEveCaloViz::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveCaloViz.
      TClass *R__cl = ::TEveCaloViz::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fData", &fData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCellIdCacheOK", &fCellIdCacheOK);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEtaMin", &fEtaMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEtaMax", &fEtaMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi", &fPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiOffset", &fPhiOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAutoRange", &fAutoRange);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBarrelRadius", &fBarrelRadius);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEndCapPos", &fEndCapPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPlotEt", &fPlotEt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxTowerH", &fMaxTowerH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaleAbs", &fScaleAbs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxValAbs", &fMaxValAbs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValueIsColor", &fValueIsColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPalette", &fPalette);
      TEveElement::ShowMembers(R__insp);
      TNamed::ShowMembers(R__insp);
      TAtt3D::ShowMembers(R__insp);
      TAttBBox::ShowMembers(R__insp);
      TEveProjectable::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveCaloViz(void *p) {
      delete ((::TEveCaloViz*)p);
   }
   static void deleteArray_TEveCaloViz(void *p) {
      delete [] ((::TEveCaloViz*)p);
   }
   static void destruct_TEveCaloViz(void *p) {
      typedef ::TEveCaloViz current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCaloViz

//______________________________________________________________________________
void TEveCaloVizEditor::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveCaloVizEditor.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveCaloVizEditor::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveCaloVizEditor::Class(),this);
   }
}

//______________________________________________________________________________
void TEveCaloVizEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveCaloVizEditor.
      TClass *R__cl = ::TEveCaloVizEditor::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(), "*fFrameTransparency", &fFrameTransparency);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPlotE", &fPlotE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPlotEt", &fPlotEt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScaleAbs", &fScaleAbs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaxValAbs", &fMaxValAbs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaxTowerH", &fMaxTowerH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEtaRng", &fEtaRng);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPhi", &fPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPhiOffset", &fPhiOffset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataFrame", &fDataFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSliceFrame", &fSliceFrame);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveCaloVizEditor(void *p) {
      return  p ? new(p) ::TEveCaloVizEditor : new ::TEveCaloVizEditor;
   }
   static void *newArray_TEveCaloVizEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveCaloVizEditor[nElements] : new ::TEveCaloVizEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveCaloVizEditor(void *p) {
      delete ((::TEveCaloVizEditor*)p);
   }
   static void deleteArray_TEveCaloVizEditor(void *p) {
      delete [] ((::TEveCaloVizEditor*)p);
   }
   static void destruct_TEveCaloVizEditor(void *p) {
      typedef ::TEveCaloVizEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCaloVizEditor

//______________________________________________________________________________
void TEveCalo3D::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveCalo3D.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveCalo3D::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveCalo3D::Class(),this);
   }
}

//______________________________________________________________________________
void TEveCalo3D::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveCalo3D.
      TClass *R__cl = ::TEveCalo3D::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCellList", (void*)&fCellList);
      R__insp.InspectMember("TEveCaloData::vCellId_t", (void*)&fCellList, "fCellList.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRnrEndCapFrame", &fRnrEndCapFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRnrBarrelFrame", &fRnrBarrelFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameWidth", &fFrameWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameColor", &fFrameColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameTransparency", &fFrameTransparency);
      TEveCaloViz::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveCalo3D(void *p) {
      return  p ? new(p) ::TEveCalo3D : new ::TEveCalo3D;
   }
   static void *newArray_TEveCalo3D(Long_t nElements, void *p) {
      return p ? new(p) ::TEveCalo3D[nElements] : new ::TEveCalo3D[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveCalo3D(void *p) {
      delete ((::TEveCalo3D*)p);
   }
   static void deleteArray_TEveCalo3D(void *p) {
      delete [] ((::TEveCalo3D*)p);
   }
   static void destruct_TEveCalo3D(void *p) {
      typedef ::TEveCalo3D current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCalo3D

//______________________________________________________________________________
void TEveCalo3DEditor::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveCalo3DEditor.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveCalo3DEditor::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveCalo3DEditor::Class(),this);
   }
}

//______________________________________________________________________________
void TEveCalo3DEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveCalo3DEditor.
      TClass *R__cl = ::TEveCalo3DEditor::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(), "*fFrameTransparency", &fFrameTransparency);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveCalo3DEditor(void *p) {
      return  p ? new(p) ::TEveCalo3DEditor : new ::TEveCalo3DEditor;
   }
   static void *newArray_TEveCalo3DEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveCalo3DEditor[nElements] : new ::TEveCalo3DEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveCalo3DEditor(void *p) {
      delete ((::TEveCalo3DEditor*)p);
   }
   static void deleteArray_TEveCalo3DEditor(void *p) {
      delete [] ((::TEveCalo3DEditor*)p);
   }
   static void destruct_TEveCalo3DEditor(void *p) {
      typedef ::TEveCalo3DEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCalo3DEditor

//______________________________________________________________________________
void TEveCalo3DGL::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveCalo3DGL.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveCalo3DGL::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveCalo3DGL::Class(),this);
   }
}

//______________________________________________________________________________
void TEveCalo3DGL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveCalo3DGL.
      TClass *R__cl = ::TEveCalo3DGL::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(), "fOffset", (void*)&fOffset);
      R__insp.InspectMember("vector<Float_t>", (void*)&fOffset, "fOffset.", false);
      TGLObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveCalo3DGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveCalo3DGL : new ::TEveCalo3DGL;
   }
   static void *newArray_TEveCalo3DGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveCalo3DGL[nElements] : new ::TEveCalo3DGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveCalo3DGL(void *p) {
      delete ((::TEveCalo3DGL*)p);
   }
   static void deleteArray_TEveCalo3DGL(void *p) {
      delete [] ((::TEveCalo3DGL*)p);
   }
   static void destruct_TEveCalo3DGL(void *p) {
      typedef ::TEveCalo3DGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCalo3DGL

//______________________________________________________________________________
void TEveCalo2D::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveCalo2D.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveCalo2D::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveCalo2D::Class(),this);
   }
}

//______________________________________________________________________________
void TEveCalo2D::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveCalo2D.
      TClass *R__cl = ::TEveCalo2D::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOldProjectionType", &fOldProjectionType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCellLists", (void*)&fCellLists);
      R__insp.InspectMember("vector<TEveCaloData::vCellId_t*>", (void*)&fCellLists, "fCellLists.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCellListsSelected", (void*)&fCellListsSelected);
      R__insp.InspectMember("vector<TEveCaloData::vCellId_t*>", (void*)&fCellListsSelected, "fCellListsSelected.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCellListsHighlighted", (void*)&fCellListsHighlighted);
      R__insp.InspectMember("vector<TEveCaloData::vCellId_t*>", (void*)&fCellListsHighlighted, "fCellListsHighlighted.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxESumBin", &fMaxESumBin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxEtSumBin", &fMaxEtSumBin);
      TEveCaloViz::ShowMembers(R__insp);
      TEveProjected::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveCalo2D(void *p) {
      return  p ? new(p) ::TEveCalo2D : new ::TEveCalo2D;
   }
   static void *newArray_TEveCalo2D(Long_t nElements, void *p) {
      return p ? new(p) ::TEveCalo2D[nElements] : new ::TEveCalo2D[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveCalo2D(void *p) {
      delete ((::TEveCalo2D*)p);
   }
   static void deleteArray_TEveCalo2D(void *p) {
      delete [] ((::TEveCalo2D*)p);
   }
   static void destruct_TEveCalo2D(void *p) {
      typedef ::TEveCalo2D current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCalo2D

//______________________________________________________________________________
void TEveCalo2DGL::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveCalo2DGL.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveCalo2DGL::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveCalo2DGL::Class(),this);
   }
}

//______________________________________________________________________________
void TEveCalo2DGL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveCalo2DGL.
      TClass *R__cl = ::TEveCalo2DGL::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fM", &fM);
      TGLObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveCalo2DGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveCalo2DGL : new ::TEveCalo2DGL;
   }
   static void *newArray_TEveCalo2DGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveCalo2DGL[nElements] : new ::TEveCalo2DGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveCalo2DGL(void *p) {
      delete ((::TEveCalo2DGL*)p);
   }
   static void deleteArray_TEveCalo2DGL(void *p) {
      delete [] ((::TEveCalo2DGL*)p);
   }
   static void destruct_TEveCalo2DGL(void *p) {
      typedef ::TEveCalo2DGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCalo2DGL

//______________________________________________________________________________
void TEveCaloLego::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveCaloLego.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveCaloLego::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveCaloLego::Class(),this);
   }
}

//______________________________________________________________________________
void TEveCaloLego::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveCaloLego.
      TClass *R__cl = ::TEveCaloLego::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCellList", (void*)&fCellList);
      R__insp.InspectMember("TEveCaloData::vCellId_t", (void*)&fCellList, "fCellList.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontColor", &fFontColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGridColor", &fGridColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPlaneColor", &fPlaneColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPlaneTransparency", &fPlaneTransparency);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNZSteps", &fNZSteps);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZAxisStep", &fZAxisStep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAutoRebin", &fAutoRebin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPixelsPerBin", &fPixelsPerBin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormalizeRebin", &fNormalizeRebin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProjection", &fProjection);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "f2DMode", &f2DMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoxMode", &fBoxMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawHPlane", &fDrawHPlane);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHPlaneVal", &fHPlaneVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasFixedHeightIn2DMode", &fHasFixedHeightIn2DMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFixedHeightValIn2DMode", &fFixedHeightValIn2DMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawNumberCellPixels", &fDrawNumberCellPixels);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCellPixelFontSize", &fCellPixelFontSize);
      TEveCaloViz::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveCaloLego(void *p) {
      return  p ? new(p) ::TEveCaloLego : new ::TEveCaloLego;
   }
   static void *newArray_TEveCaloLego(Long_t nElements, void *p) {
      return p ? new(p) ::TEveCaloLego[nElements] : new ::TEveCaloLego[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveCaloLego(void *p) {
      delete ((::TEveCaloLego*)p);
   }
   static void deleteArray_TEveCaloLego(void *p) {
      delete [] ((::TEveCaloLego*)p);
   }
   static void destruct_TEveCaloLego(void *p) {
      typedef ::TEveCaloLego current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCaloLego

//______________________________________________________________________________
void TEveCaloLegoEditor::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveCaloLegoEditor.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveCaloLegoEditor::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveCaloLegoEditor::Class(),this);
   }
}

//______________________________________________________________________________
void TEveCaloLegoEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveCaloLegoEditor.
      TClass *R__cl = ::TEveCaloLegoEditor::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(), "*fGridColor", &fGridColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFontColor", &fFontColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPlaneColor", &fPlaneColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransparency", &fTransparency);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProjection", &fProjection);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*f2DMode", &f2DMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxMode", &fBoxMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCell2DTextMin", &fCell2DTextMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRebinFrame", &fRebinFrame);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAutoRebin", &fAutoRebin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPixelsPerBin", &fPixelsPerBin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNormalizeRebin", &fNormalizeRebin);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveCaloLegoEditor(void *p) {
      return  p ? new(p) ::TEveCaloLegoEditor : new ::TEveCaloLegoEditor;
   }
   static void *newArray_TEveCaloLegoEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveCaloLegoEditor[nElements] : new ::TEveCaloLegoEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveCaloLegoEditor(void *p) {
      delete ((::TEveCaloLegoEditor*)p);
   }
   static void deleteArray_TEveCaloLegoEditor(void *p) {
      delete [] ((::TEveCaloLegoEditor*)p);
   }
   static void destruct_TEveCaloLegoEditor(void *p) {
      typedef ::TEveCaloLegoEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCaloLegoEditor

//______________________________________________________________________________
void TEveCaloLegoGL::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveCaloLegoGL.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveCaloLegoGL::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveCaloLegoGL::Class(),this);
   }
}

//______________________________________________________________________________
void TEveCaloLegoGL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveCaloLegoGL.
      TClass *R__cl = ::TEveCaloLegoGL::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGridColor", &fGridColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFontColor", &fFontColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEtaAxis", &fEtaAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPhiAxis", &fPhiAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZAxis", &fZAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXAxisTitlePos", &fXAxisTitlePos);
      R__insp.InspectMember(fXAxisTitlePos, "fXAxisTitlePos.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fYAxisTitlePos", &fYAxisTitlePos);
      R__insp.InspectMember(fYAxisTitlePos, "fYAxisTitlePos.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZAxisTitlePos", &fZAxisTitlePos);
      R__insp.InspectMember(fZAxisTitlePos, "fZAxisTitlePos.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBackPlaneXConst[2]", fBackPlaneXConst);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBackPlaneYConst[2]", fBackPlaneYConst);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxisPainter", &fAxisPainter);
      R__insp.InspectMember(fAxisPainter, "fAxisPainter.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fM", &fM);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDLCacheOK", &fDLCacheOK);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCells2D", (void*)&fCells2D);
      R__insp.InspectMember("TEveCaloLegoGL::vCell2D_t", (void*)&fCells2D, "fCells2D.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRebinData", (void*)&fRebinData);
      R__insp.InspectMember("TEveCaloData::RebinData_t", (void*)&fRebinData, "fRebinData.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxVal", &fMaxVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValToPixel", &fValToPixel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentPixelsPerBin", &fCurrentPixelsPerBin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDLMap", (void*)&fDLMap);
      R__insp.InspectMember("TEveCaloLegoGL::SliceDLMap_t", (void*)&fDLMap, "fDLMap.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCells3D", &fCells3D);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinStep", &fBinStep);
      TGLObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveCaloLegoGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveCaloLegoGL : new ::TEveCaloLegoGL;
   }
   static void *newArray_TEveCaloLegoGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveCaloLegoGL[nElements] : new ::TEveCaloLegoGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveCaloLegoGL(void *p) {
      delete ((::TEveCaloLegoGL*)p);
   }
   static void deleteArray_TEveCaloLegoGL(void *p) {
      delete [] ((::TEveCaloLegoGL*)p);
   }
   static void destruct_TEveCaloLegoGL(void *p) {
      typedef ::TEveCaloLegoGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCaloLegoGL

//______________________________________________________________________________
void TEveCaloLegoOverlay::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveCaloLegoOverlay.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveCaloLegoOverlay::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveCaloLegoOverlay::Class(),this);
   }
}

//______________________________________________________________________________
void TEveCaloLegoOverlay::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveCaloLegoOverlay.
      TClass *R__cl = ::TEveCaloLegoOverlay::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCalo", &fCalo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowScales", &fShowScales);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaleColor", &fScaleColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaleTransparency", &fScaleTransparency);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaleCoordX", &fScaleCoordX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaleCoordY", &fScaleCoordY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaleW", &fScaleW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaleH", &fScaleH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCellX", &fCellX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCellY", &fCellY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameColor", &fFrameColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameLineTransp", &fFrameLineTransp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameBgTransp", &fFrameBgTransp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMouseX", &fMouseX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMouseY", &fMouseY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInDrag", &fInDrag);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHeaderTxt", &fHeaderTxt);
      R__insp.InspectMember(fHeaderTxt, "fHeaderTxt.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHeaderSelected", &fHeaderSelected);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPlaneAxis", &fPlaneAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxisPlaneColor", &fAxisPlaneColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowPlane", &fShowPlane);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMenuW", &fMenuW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fButtonW", &fButtonW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowSlider", &fShowSlider);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSliderH", &fSliderH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSliderPosY", &fSliderPosY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSliderVal", &fSliderVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActiveID", &fActiveID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActiveCol", &fActiveCol);
      TGLCameraOverlay::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveCaloLegoOverlay(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveCaloLegoOverlay : new ::TEveCaloLegoOverlay;
   }
   static void *newArray_TEveCaloLegoOverlay(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveCaloLegoOverlay[nElements] : new ::TEveCaloLegoOverlay[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveCaloLegoOverlay(void *p) {
      delete ((::TEveCaloLegoOverlay*)p);
   }
   static void deleteArray_TEveCaloLegoOverlay(void *p) {
      delete [] ((::TEveCaloLegoOverlay*)p);
   }
   static void destruct_TEveCaloLegoOverlay(void *p) {
      typedef ::TEveCaloLegoOverlay current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveCaloLegoOverlay

//______________________________________________________________________________
void TEveLegoEventHandler::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveLegoEventHandler.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveLegoEventHandler::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveLegoEventHandler::Class(),this);
   }
}

//______________________________________________________________________________
void TEveLegoEventHandler::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveLegoEventHandler.
      TClass *R__cl = ::TEveLegoEventHandler::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMode", &fMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTransTheta", &fTransTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta", &fTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLego", &fLego);
      TGLEventHandler::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveLegoEventHandler(void *p) {
      delete ((::TEveLegoEventHandler*)p);
   }
   static void deleteArray_TEveLegoEventHandler(void *p) {
      delete [] ((::TEveLegoEventHandler*)p);
   }
   static void destruct_TEveLegoEventHandler(void *p) {
      typedef ::TEveLegoEventHandler current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveLegoEventHandler

//______________________________________________________________________________
void TEveJetCone::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveJetCone.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveJetCone::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveJetCone::Class(),this);
   }
}

//______________________________________________________________________________
void TEveJetCone::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveJetCone.
      TClass *R__cl = ::TEveJetCone::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fApex", &fApex);
      R__insp.InspectMember(fApex, "fApex.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxis", &fAxis);
      R__insp.InspectMember(fAxis, "fAxis.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLimits", &fLimits);
      R__insp.InspectMember(fLimits, "fLimits.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fThetaC", &fThetaC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEta", &fEta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi", &fPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDEta", &fDEta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDPhi", &fDPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNDiv", &fNDiv);
      TEveShape::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveJetCone(void *p) {
      return  p ? new(p) ::TEveJetCone : new ::TEveJetCone;
   }
   static void *newArray_TEveJetCone(Long_t nElements, void *p) {
      return p ? new(p) ::TEveJetCone[nElements] : new ::TEveJetCone[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveJetCone(void *p) {
      delete ((::TEveJetCone*)p);
   }
   static void deleteArray_TEveJetCone(void *p) {
      delete [] ((::TEveJetCone*)p);
   }
   static void destruct_TEveJetCone(void *p) {
      typedef ::TEveJetCone current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveJetCone

//______________________________________________________________________________
void TEveJetConeEditor::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveJetConeEditor.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveJetConeEditor::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveJetConeEditor::Class(),this);
   }
}

//______________________________________________________________________________
void TEveJetConeEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveJetConeEditor.
      TClass *R__cl = ::TEveJetConeEditor::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fM", &fM);
      TGedFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveJetConeEditor(void *p) {
      return  p ? new(p) ::TEveJetConeEditor : new ::TEveJetConeEditor;
   }
   static void *newArray_TEveJetConeEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveJetConeEditor[nElements] : new ::TEveJetConeEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveJetConeEditor(void *p) {
      delete ((::TEveJetConeEditor*)p);
   }
   static void deleteArray_TEveJetConeEditor(void *p) {
      delete [] ((::TEveJetConeEditor*)p);
   }
   static void destruct_TEveJetConeEditor(void *p) {
      typedef ::TEveJetConeEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveJetConeEditor

//______________________________________________________________________________
void TEveJetConeGL::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveJetConeGL.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveJetConeGL::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveJetConeGL::Class(),this);
   }
}

//______________________________________________________________________________
void TEveJetConeGL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveJetConeGL.
      TClass *R__cl = ::TEveJetConeGL::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fC", &fC);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP", (void*)&fP);
      R__insp.InspectMember("vector<TEveVector>", (void*)&fP, "fP.", false);
      TGLObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveJetConeGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveJetConeGL : new ::TEveJetConeGL;
   }
   static void *newArray_TEveJetConeGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveJetConeGL[nElements] : new ::TEveJetConeGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveJetConeGL(void *p) {
      delete ((::TEveJetConeGL*)p);
   }
   static void deleteArray_TEveJetConeGL(void *p) {
      delete [] ((::TEveJetConeGL*)p);
   }
   static void destruct_TEveJetConeGL(void *p) {
      typedef ::TEveJetConeGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveJetConeGL

//______________________________________________________________________________
void TEveJetConeProjected::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveJetConeProjected.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveJetConeProjected::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveJetConeProjected::Class(),this);
   }
}

//______________________________________________________________________________
void TEveJetConeProjected::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveJetConeProjected.
      TClass *R__cl = ::TEveJetConeProjected::IsA();
      if (R__cl || R__insp.IsA()) { }
      TEveShape::ShowMembers(R__insp);
      TEveProjected::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveJetConeProjected(void *p) {
      return  p ? new(p) ::TEveJetConeProjected : new ::TEveJetConeProjected;
   }
   static void *newArray_TEveJetConeProjected(Long_t nElements, void *p) {
      return p ? new(p) ::TEveJetConeProjected[nElements] : new ::TEveJetConeProjected[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveJetConeProjected(void *p) {
      delete ((::TEveJetConeProjected*)p);
   }
   static void deleteArray_TEveJetConeProjected(void *p) {
      delete [] ((::TEveJetConeProjected*)p);
   }
   static void destruct_TEveJetConeProjected(void *p) {
      typedef ::TEveJetConeProjected current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveJetConeProjected

//______________________________________________________________________________
void TEveJetConeProjectedGL::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveJetConeProjectedGL.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveJetConeProjectedGL::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveJetConeProjectedGL::Class(),this);
   }
}

//______________________________________________________________________________
void TEveJetConeProjectedGL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveJetConeProjectedGL.
      TClass *R__cl = ::TEveJetConeProjectedGL::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fM", &fM);
      TEveJetConeGL::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveJetConeProjectedGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveJetConeProjectedGL : new ::TEveJetConeProjectedGL;
   }
   static void *newArray_TEveJetConeProjectedGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEveJetConeProjectedGL[nElements] : new ::TEveJetConeProjectedGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveJetConeProjectedGL(void *p) {
      delete ((::TEveJetConeProjectedGL*)p);
   }
   static void deleteArray_TEveJetConeProjectedGL(void *p) {
      delete [] ((::TEveJetConeProjectedGL*)p);
   }
   static void destruct_TEveJetConeProjectedGL(void *p) {
      typedef ::TEveJetConeProjectedGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveJetConeProjectedGL

//______________________________________________________________________________
void TEvePlot3D::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEvePlot3D.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEvePlot3D::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEvePlot3D::Class(),this);
   }
}

//______________________________________________________________________________
void TEvePlot3D::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEvePlot3D.
      TClass *R__cl = ::TEvePlot3D::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPlot", &fPlot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPlotOption", &fPlotOption);
      R__insp.InspectMember(fPlotOption, "fPlotOption.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogX", &fLogX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogY", &fLogY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogZ", &fLogZ);
      TEveElementList::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvePlot3D(void *p) {
      return  p ? new(p) ::TEvePlot3D : new ::TEvePlot3D;
   }
   static void *newArray_TEvePlot3D(Long_t nElements, void *p) {
      return p ? new(p) ::TEvePlot3D[nElements] : new ::TEvePlot3D[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvePlot3D(void *p) {
      delete ((::TEvePlot3D*)p);
   }
   static void deleteArray_TEvePlot3D(void *p) {
      delete [] ((::TEvePlot3D*)p);
   }
   static void destruct_TEvePlot3D(void *p) {
      typedef ::TEvePlot3D current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvePlot3D

//______________________________________________________________________________
void TEvePlot3DGL::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEvePlot3DGL.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEvePlot3DGL::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEvePlot3DGL::Class(),this);
   }
}

//______________________________________________________________________________
void TEvePlot3DGL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEvePlot3DGL.
      TClass *R__cl = ::TEvePlot3DGL::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(), "*fPlotLogical", &fPlotLogical);
      TGLObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEvePlot3DGL(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEvePlot3DGL : new ::TEvePlot3DGL;
   }
   static void *newArray_TEvePlot3DGL(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TEvePlot3DGL[nElements] : new ::TEvePlot3DGL[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEvePlot3DGL(void *p) {
      delete ((::TEvePlot3DGL*)p);
   }
   static void deleteArray_TEvePlot3DGL(void *p) {
      delete [] ((::TEvePlot3DGL*)p);
   }
   static void destruct_TEvePlot3DGL(void *p) {
      typedef ::TEvePlot3DGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEvePlot3DGL

//______________________________________________________________________________
void TEveFrameBox::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveFrameBox.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveFrameBox::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveFrameBox::Class(),this);
   }
}

//______________________________________________________________________________
void TEveFrameBox::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveFrameBox.
      TClass *R__cl = ::TEveFrameBox::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameType", &fFrameType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameSize", &fFrameSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFramePoints", &fFramePoints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameWidth", &fFrameWidth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameColor", &fFrameColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBackColor", &fBackColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameRGBA[4]", fFrameRGBA);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBackRGBA[4]", fBackRGBA);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameFill", &fFrameFill);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawBack", &fDrawBack);
      TObject::ShowMembers(R__insp);
      TEveRefBackPtr::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveFrameBox(void *p) {
      return  p ? new(p) ::TEveFrameBox : new ::TEveFrameBox;
   }
   static void *newArray_TEveFrameBox(Long_t nElements, void *p) {
      return p ? new(p) ::TEveFrameBox[nElements] : new ::TEveFrameBox[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveFrameBox(void *p) {
      delete ((::TEveFrameBox*)p);
   }
   static void deleteArray_TEveFrameBox(void *p) {
      delete [] ((::TEveFrameBox*)p);
   }
   static void destruct_TEveFrameBox(void *p) {
      typedef ::TEveFrameBox current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveFrameBox

//______________________________________________________________________________
void TEveFrameBoxGL::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveFrameBoxGL.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveFrameBoxGL::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveFrameBoxGL::Class(),this);
   }
}

//______________________________________________________________________________
void TEveFrameBoxGL::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveFrameBoxGL.
      TClass *R__cl = ::TEveFrameBoxGL::IsA();
      if (R__cl || R__insp.IsA()) { }
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveFrameBoxGL(void *p) {
      delete ((::TEveFrameBoxGL*)p);
   }
   static void deleteArray_TEveFrameBoxGL(void *p) {
      delete [] ((::TEveFrameBoxGL*)p);
   }
   static void destruct_TEveFrameBoxGL(void *p) {
      typedef ::TEveFrameBoxGL current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveFrameBoxGL

//______________________________________________________________________________
void TEveGridStepper::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveGridStepper.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveGridStepper::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveGridStepper::Class(),this);
   }
}

//______________________________________________________________________________
void TEveGridStepper::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveGridStepper.
      TClass *R__cl = ::TEveGridStepper::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLimitArr[3]", &fLimitArr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValueArr[3]", &fValueArr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMode", &fMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCx", &fCx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCy", &fCy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCz", &fCz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNx", &fNx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNy", &fNy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNz", &fNz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDx", &fDx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDy", &fDy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDz", &fDz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOx", &fOx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOy", &fOy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOz", &fOz);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveGridStepper(void *p) {
      return  p ? new(p) ::TEveGridStepper : new ::TEveGridStepper;
   }
   static void *newArray_TEveGridStepper(Long_t nElements, void *p) {
      return p ? new(p) ::TEveGridStepper[nElements] : new ::TEveGridStepper[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveGridStepper(void *p) {
      delete ((::TEveGridStepper*)p);
   }
   static void deleteArray_TEveGridStepper(void *p) {
      delete [] ((::TEveGridStepper*)p);
   }
   static void destruct_TEveGridStepper(void *p) {
      typedef ::TEveGridStepper current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGridStepper

//______________________________________________________________________________
void TEveGridStepperSubEditor::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveGridStepperSubEditor.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveGridStepperSubEditor::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveGridStepperSubEditor::Class(),this);
   }
}

//______________________________________________________________________________
void TEveGridStepperSubEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveGridStepperSubEditor.
      TClass *R__cl = ::TEveGridStepperSubEditor::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(), "*fNx", &fNx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNy", &fNy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNz", &fNz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDx", &fDx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDy", &fDy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDz", &fDz);
      TGVerticalFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveGridStepperSubEditor(void *p) {
      delete ((::TEveGridStepperSubEditor*)p);
   }
   static void deleteArray_TEveGridStepperSubEditor(void *p) {
      delete [] ((::TEveGridStepperSubEditor*)p);
   }
   static void destruct_TEveGridStepperSubEditor(void *p) {
      typedef ::TEveGridStepperSubEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGridStepperSubEditor

//______________________________________________________________________________
void TEveGridStepperEditor::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveGridStepperEditor.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveGridStepperEditor::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveGridStepperEditor::Class(),this);
   }
}

//______________________________________________________________________________
void TEveGridStepperEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveGridStepperEditor.
      TClass *R__cl = ::TEveGridStepperEditor::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_TEveGridStepperEditor(void *p) {
      return  p ? new(p) ::TEveGridStepperEditor : new ::TEveGridStepperEditor;
   }
   static void *newArray_TEveGridStepperEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveGridStepperEditor[nElements] : new ::TEveGridStepperEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveGridStepperEditor(void *p) {
      delete ((::TEveGridStepperEditor*)p);
   }
   static void deleteArray_TEveGridStepperEditor(void *p) {
      delete [] ((::TEveGridStepperEditor*)p);
   }
   static void destruct_TEveGridStepperEditor(void *p) {
      typedef ::TEveGridStepperEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveGridStepperEditor

//______________________________________________________________________________
void TEveRGBAPalette::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveRGBAPalette.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveRGBAPalette::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveRGBAPalette::Class(),this);
   }
}

//______________________________________________________________________________
void TEveRGBAPalette::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveRGBAPalette.
      TClass *R__cl = ::TEveRGBAPalette::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowLimit", &fLowLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighLimit", &fHighLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinVal", &fMinVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxVal", &fMaxVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterpolate", &fInterpolate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShowDefValue", &fShowDefValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFixColorRange", &fFixColorRange);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUnderflowAction", &fUnderflowAction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOverflowAction", &fOverflowAction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultColor", &fDefaultColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultRGBA[4]", fDefaultRGBA);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUnderColor", &fUnderColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUnderRGBA[4]", fUnderRGBA);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOverColor", &fOverColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOverRGBA[4]", fOverRGBA);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNBins", &fNBins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCAMin", &fCAMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCAMax", &fCAMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorArray", &fColorArray);
      TObject::ShowMembers(R__insp);
      TQObject::ShowMembers(R__insp);
      TEveRefCnt::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TEveRGBAPalette(void *p) {
      return  p ? new(p) ::TEveRGBAPalette : new ::TEveRGBAPalette;
   }
   static void *newArray_TEveRGBAPalette(Long_t nElements, void *p) {
      return p ? new(p) ::TEveRGBAPalette[nElements] : new ::TEveRGBAPalette[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveRGBAPalette(void *p) {
      delete ((::TEveRGBAPalette*)p);
   }
   static void deleteArray_TEveRGBAPalette(void *p) {
      delete [] ((::TEveRGBAPalette*)p);
   }
   static void destruct_TEveRGBAPalette(void *p) {
      typedef ::TEveRGBAPalette current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveRGBAPalette

//______________________________________________________________________________
void TEveRGBAPaletteEditor::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveRGBAPaletteEditor.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveRGBAPaletteEditor::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveRGBAPaletteEditor::Class(),this);
   }
}

//______________________________________________________________________________
void TEveRGBAPaletteEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveRGBAPaletteEditor.
      TClass *R__cl = ::TEveRGBAPaletteEditor::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_TEveRGBAPaletteEditor(void *p) {
      return  p ? new(p) ::TEveRGBAPaletteEditor : new ::TEveRGBAPaletteEditor;
   }
   static void *newArray_TEveRGBAPaletteEditor(Long_t nElements, void *p) {
      return p ? new(p) ::TEveRGBAPaletteEditor[nElements] : new ::TEveRGBAPaletteEditor[nElements];
   }
   // Wrapper around operator delete
   static void delete_TEveRGBAPaletteEditor(void *p) {
      delete ((::TEveRGBAPaletteEditor*)p);
   }
   static void deleteArray_TEveRGBAPaletteEditor(void *p) {
      delete [] ((::TEveRGBAPaletteEditor*)p);
   }
   static void destruct_TEveRGBAPaletteEditor(void *p) {
      typedef ::TEveRGBAPaletteEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveRGBAPaletteEditor

//______________________________________________________________________________
void TEveRGBAPaletteSubEditor::Streamer(TBuffer &R__b)
{
   // Stream an object of class TEveRGBAPaletteSubEditor.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TEveRGBAPaletteSubEditor::Class(),this);
   } else {
      R__b.WriteClassBuffer(TEveRGBAPaletteSubEditor::Class(),this);
   }
}

//______________________________________________________________________________
void TEveRGBAPaletteSubEditor::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TEveRGBAPaletteSubEditor.
      TClass *R__cl = ::TEveRGBAPaletteSubEditor::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(), "*fUnderflowAction", &fUnderflowAction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUnderColor", &fUnderColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOverflowAction", &fOverflowAction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOverColor", &fOverColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMinMax", &fMinMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInterpolate", &fInterpolate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShowDefValue", &fShowDefValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDefaultColor", &fDefaultColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFixColorRange", &fFixColorRange);
      TGVerticalFrame::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TEveRGBAPaletteSubEditor(void *p) {
      delete ((::TEveRGBAPaletteSubEditor*)p);
   }
   static void deleteArray_TEveRGBAPaletteSubEditor(void *p) {
      delete [] ((::TEveRGBAPaletteSubEditor*)p);
   }
   static void destruct_TEveRGBAPaletteSubEditor(void *p) {
      typedef ::TEveRGBAPaletteSubEditor current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TEveRGBAPaletteSubEditor

namespace ROOT {
   void vectorlETEvePathMarkTlEfloatgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlETEvePathMarkTlEfloatgRsPgR_Dictionary();
   static void *new_vectorlETEvePathMarkTlEfloatgRsPgR(void *p = 0);
   static void *newArray_vectorlETEvePathMarkTlEfloatgRsPgR(Long_t size, void *p);
   static void delete_vectorlETEvePathMarkTlEfloatgRsPgR(void *p);
   static void deleteArray_vectorlETEvePathMarkTlEfloatgRsPgR(void *p);
   static void destruct_vectorlETEvePathMarkTlEfloatgRsPgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<TEvePathMarkT<float> >*)
   {
      vector<TEvePathMarkT<float> > *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<TEvePathMarkT<float> >),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<TEvePathMarkT<float> >", -2, "prec_stl/vector", 49,
                  typeid(vector<TEvePathMarkT<float> >), DefineBehavior(ptr, ptr),
                  0, &vectorlETEvePathMarkTlEfloatgRsPgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<TEvePathMarkT<float> >) );
      instance.SetNew(&new_vectorlETEvePathMarkTlEfloatgRsPgR);
      instance.SetNewArray(&newArray_vectorlETEvePathMarkTlEfloatgRsPgR);
      instance.SetDelete(&delete_vectorlETEvePathMarkTlEfloatgRsPgR);
      instance.SetDeleteArray(&deleteArray_vectorlETEvePathMarkTlEfloatgRsPgR);
      instance.SetDestructor(&destruct_vectorlETEvePathMarkTlEfloatgRsPgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<TEvePathMarkT<float> > >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<TEvePathMarkT<float> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlETEvePathMarkTlEfloatgRsPgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<TEvePathMarkT<float> >*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlETEvePathMarkTlEfloatgRsPgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TEvePathMarkT<float> > : new vector<TEvePathMarkT<float> >;
   }
   static void *newArray_vectorlETEvePathMarkTlEfloatgRsPgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<TEvePathMarkT<float> >[nElements] : new vector<TEvePathMarkT<float> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlETEvePathMarkTlEfloatgRsPgR(void *p) {
      delete ((vector<TEvePathMarkT<float> >*)p);
   }
   static void deleteArray_vectorlETEvePathMarkTlEfloatgRsPgR(void *p) {
      delete [] ((vector<TEvePathMarkT<float> >*)p);
   }
   static void destruct_vectorlETEvePathMarkTlEfloatgRsPgR(void *p) {
      typedef vector<TEvePathMarkT<float> > current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<TEvePathMarkT<float> >

namespace ROOT {
   void vectorlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEdoublegR_Dictionary();
   static void *new_vectorlEdoublegR(void *p = 0);
   static void *newArray_vectorlEdoublegR(Long_t size, void *p);
   static void delete_vectorlEdoublegR(void *p);
   static void deleteArray_vectorlEdoublegR(void *p);
   static void destruct_vectorlEdoublegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<double>*)
   {
      vector<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<double>", -2, "prec_stl/vector", 49,
                  typeid(vector<double>), DefineBehavior(ptr, ptr),
                  0, &vectorlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(vector<double>) );
      instance.SetNew(&new_vectorlEdoublegR);
      instance.SetNewArray(&newArray_vectorlEdoublegR);
      instance.SetDelete(&delete_vectorlEdoublegR);
      instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
      instance.SetDestructor(&destruct_vectorlEdoublegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<double> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double> : new vector<double>;
   }
   static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double>[nElements] : new vector<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEdoublegR(void *p) {
      delete ((vector<double>*)p);
   }
   static void deleteArray_vectorlEdoublegR(void *p) {
      delete [] ((vector<double>*)p);
   }
   static void destruct_vectorlEdoublegR(void *p) {
      typedef vector<double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<double>

namespace ROOT {
   void vectorlEintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEintgR_Dictionary();
   static void *new_vectorlEintgR(void *p = 0);
   static void *newArray_vectorlEintgR(Long_t size, void *p);
   static void delete_vectorlEintgR(void *p);
   static void deleteArray_vectorlEintgR(void *p);
   static void destruct_vectorlEintgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<int>*)
   {
      vector<int> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<int>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<int>", -2, "prec_stl/vector", 49,
                  typeid(vector<int>), DefineBehavior(ptr, ptr),
                  0, &vectorlEintgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<int>) );
      instance.SetNew(&new_vectorlEintgR);
      instance.SetNewArray(&newArray_vectorlEintgR);
      instance.SetDelete(&delete_vectorlEintgR);
      instance.SetDeleteArray(&deleteArray_vectorlEintgR);
      instance.SetDestructor(&destruct_vectorlEintgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<int> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEintgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<int>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEintgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<int> : new vector<int>;
   }
   static void *newArray_vectorlEintgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<int>[nElements] : new vector<int>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEintgR(void *p) {
      delete ((vector<int>*)p);
   }
   static void deleteArray_vectorlEintgR(void *p) {
      delete [] ((vector<int>*)p);
   }
   static void destruct_vectorlEintgR(void *p) {
      typedef vector<int> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<int>

/********************************************************
* graf3d/eve/src/G__Eve2.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__Eve2();

extern "C" void G__set_cpp_environmentG__Eve2() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TEveArrowEditor.h");
  G__add_compiledheader("TEveArrowGL.h");
  G__add_compiledheader("TEveArrow.h");
  G__add_compiledheader("TEveBoxGL.h");
  G__add_compiledheader("TEveBox.h");
  G__add_compiledheader("TEveBoxSetGL.h");
  G__add_compiledheader("TEveBoxSet.h");
  G__add_compiledheader("TEveCalo2DGL.h");
  G__add_compiledheader("TEveCalo3DGL.h");
  G__add_compiledheader("TEveCaloData.h");
  G__add_compiledheader("TEveCalo.h");
  G__add_compiledheader("TEveCaloLegoEditor.h");
  G__add_compiledheader("TEveCaloLegoGL.h");
  G__add_compiledheader("TEveCaloLegoOverlay.h");
  G__add_compiledheader("TEveCaloVizEditor.h");
  G__add_compiledheader("TEveDigitSetEditor.h");
  G__add_compiledheader("TEveDigitSetGL.h");
  G__add_compiledheader("TEveDigitSet.h");
  G__add_compiledheader("TEveFrameBoxGL.h");
  G__add_compiledheader("TEveFrameBox.h");
  G__add_compiledheader("TEveGeoNodeEditor.h");
  G__add_compiledheader("TEveGeoNode.h");
  G__add_compiledheader("TEveGeoPolyShape.h");
  G__add_compiledheader("TEveGeoShapeExtract.h");
  G__add_compiledheader("TEveGeoShape.h");
  G__add_compiledheader("TEveGridStepperEditor.h");
  G__add_compiledheader("TEveGridStepper.h");
  G__add_compiledheader("TEveLegoEventHandler.h");
  G__add_compiledheader("TEveShapeEditor.h");
  G__add_compiledheader("TEveShape.h");
  G__add_compiledheader("TEveLineEditor.h");
  G__add_compiledheader("TEveLineGL.h");
  G__add_compiledheader("TEveLine.h");
  G__add_compiledheader("TEvePointSetArrayEditor.h");
  G__add_compiledheader("TEvePointSet.h");
  G__add_compiledheader("TEvePolygonSetProjectedGL.h");
  G__add_compiledheader("TEvePolygonSetProjected.h");
  G__add_compiledheader("TEveQuadSetGL.h");
  G__add_compiledheader("TEveQuadSet.h");
  G__add_compiledheader("TEveRGBAPaletteEditor.h");
  G__add_compiledheader("TEveRGBAPalette.h");
  G__add_compiledheader("TEveScalableStraightLineSet.h");
  G__add_compiledheader("TEveStraightLineSetEditor.h");
  G__add_compiledheader("TEveStraightLineSetGL.h");
  G__add_compiledheader("TEveStraightLineSet.h");
  G__add_compiledheader("TEveTextEditor.h");
  G__add_compiledheader("TEveTextGL.h");
  G__add_compiledheader("TEveText.h");
  G__add_compiledheader("TEveTrackEditor.h");
  G__add_compiledheader("TEveTrackGL.h");
  G__add_compiledheader("TEveTrack.h");
  G__add_compiledheader("TEveTrackProjectedGL.h");
  G__add_compiledheader("TEveTrackProjected.h");
  G__add_compiledheader("TEveTrackPropagatorEditor.h");
  G__add_compiledheader("TEveTrackPropagator.h");
  G__add_compiledheader("TEveTriangleSetEditor.h");
  G__add_compiledheader("TEveTriangleSetGL.h");
  G__add_compiledheader("TEveTriangleSet.h");
  G__add_compiledheader("TEveJetConeEditor.h");
  G__add_compiledheader("TEveJetConeGL.h");
  G__add_compiledheader("TEveJetCone.h");
  G__add_compiledheader("TEvePlot3DGL.h");
  G__add_compiledheader("TEvePlot3D.h");
  G__add_compiledheader("/misc/hadessoftware/etch32/install/root-5.28.00b/graf3d/eve/src/SolarisCCDictHack.h");
  G__cpp_reset_tagtableG__Eve2();
}
#include <new>
extern "C" int G__cpp_dllrevG__Eve2() { return(30051515); }

/*********************************************************
* Member function Interface Method
*********************************************************/

/* TEveArrow */
static int G__G__Eve2_230_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveArrow* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveArrow(
(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])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TEveArrow(
(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])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveArrow(
(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])
, (Float_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TEveArrow(
(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])
, (Float_t) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveArrow(
(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) TEveArrow(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveArrow(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveArrow(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveArrow((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveArrow((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveArrow((Float_t) G__double(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveArrow((Float_t) G__double(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveArrow[n];
       } else {
         p = new((void*) gvp) TEveArrow[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveArrow;
       } else {
         p = new((void*) gvp) TEveArrow;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveArrow));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_230_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveArrow*) G__getstructoffset())->SetTubeR((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_230_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveArrow*) G__getstructoffset())->SetConeR((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_230_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveArrow*) G__getstructoffset())->SetConeL((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_230_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveArrow*) G__getstructoffset())->GetTubeR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_230_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveArrow*) G__getstructoffset())->GetConeR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_230_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveArrow*) G__getstructoffset())->GetConeL());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_230_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector* pobj;
         TEveVector xobj = ((TEveArrow*) G__getstructoffset())->GetVector();
         pobj = new TEveVector(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__Eve2_230_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector* pobj;
         TEveVector xobj = ((TEveArrow*) G__getstructoffset())->GetOrigin();
         pobj = new TEveVector(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__Eve2_230_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveArrow*) G__getstructoffset())->GetDrawQuality());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_230_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveArrow*) G__getstructoffset())->SetDrawQuality((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_230_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveArrow::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_230_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveArrow::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_230_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveArrow::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_230_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveArrow::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_230_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveArrow*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_230_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveArrow::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_230_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveArrow::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_230_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveArrow::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_230_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveArrow::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveArrow G__TTEveArrow;
static int G__G__Eve2_230_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[] (TEveArrow*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveArrow*) (soff+(sizeof(TEveArrow)*i)))->~G__TTEveArrow();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveArrow*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveArrow*) (soff))->~G__TTEveArrow();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveArrowEditor */
static int G__G__Eve2_232_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveArrowEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveArrowEditor(
(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) TEveArrowEditor(
(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 TEveArrowEditor(
(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) TEveArrowEditor(
(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 TEveArrowEditor(
(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) TEveArrowEditor(
(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 TEveArrowEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveArrowEditor((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 TEveArrowEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveArrowEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveArrowEditor[n];
       } else {
         p = new((void*) gvp) TEveArrowEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveArrowEditor;
       } else {
         p = new((void*) gvp) TEveArrowEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_232_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveArrowEditor*) G__getstructoffset())->DoTubeR();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_232_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveArrowEditor*) G__getstructoffset())->DoConeR();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_232_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveArrowEditor*) G__getstructoffset())->DoConeL();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_232_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveArrowEditor*) G__getstructoffset())->DoVertex();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_232_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveArrowEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_232_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveArrowEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_232_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveArrowEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_232_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveArrowEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_232_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveArrowEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_232_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveArrowEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_232_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveArrowEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_232_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveArrowEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_232_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveArrowEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveArrowEditor G__TTEveArrowEditor;
static int G__G__Eve2_232_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[] (TEveArrowEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveArrowEditor*) (soff+(sizeof(TEveArrowEditor)*i)))->~G__TTEveArrowEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveArrowEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveArrowEditor*) (soff))->~G__TTEveArrowEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveArrowGL */
static int G__G__Eve2_316_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveArrowGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveArrowGL[n];
     } else {
       p = new((void*) gvp) TEveArrowGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveArrowGL;
     } else {
       p = new((void*) gvp) TEveArrowGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_316_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveArrowGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_316_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveArrowGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_316_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveArrowGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_316_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveArrowGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_316_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveArrowGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_316_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveArrowGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_316_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveArrowGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_316_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveArrowGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_316_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveArrowGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveArrowGL G__TTEveArrowGL;
static int G__G__Eve2_316_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[] (TEveArrowGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveArrowGL*) (soff+(sizeof(TEveArrowGL)*i)))->~G__TTEveArrowGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveArrowGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveArrowGL*) (soff))->~G__TTEveArrowGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveBox */
static int G__G__Eve2_383_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveBox((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveBox((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 TEveBox((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveBox((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 TEveBox[n];
       } else {
         p = new((void*) gvp) TEveBox[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveBox;
       } else {
         p = new((void*) gvp) TEveBox;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_383_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBox*) G__getstructoffset())->SetVertex((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_383_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBox*) G__getstructoffset())->SetVertex((Int_t) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_383_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBox*) G__getstructoffset())->SetVertices((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_383_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TEveBox*) G__getstructoffset())->GetVertex((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_383_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveBox::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_383_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBox::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_383_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveBox::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_383_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveBox::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_383_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBox*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_383_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBox::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_383_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveBox::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_383_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBox::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_383_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveBox::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveBox G__TTEveBox;
static int G__G__Eve2_383_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[] (TEveBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveBox*) (soff+(sizeof(TEveBox)*i)))->~G__TTEveBox();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveBox*) (soff))->~G__TTEveBox();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveBoxProjected */
static int G__G__Eve2_384_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveBoxProjected* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveBoxProjected((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveBoxProjected((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 TEveBoxProjected((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveBoxProjected((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 TEveBoxProjected[n];
       } else {
         p = new((void*) gvp) TEveBoxProjected[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveBoxProjected;
       } else {
         p = new((void*) gvp) TEveBoxProjected;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjected));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_384_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TEveBoxProjected::GetDebugCornerPoints());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_384_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveBoxProjected::SetDebugCornerPoints((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_384_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveBoxProjected::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_384_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBoxProjected::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_384_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveBoxProjected::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_384_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveBoxProjected::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_384_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBoxProjected*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_384_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBoxProjected::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_384_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveBoxProjected::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_384_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBoxProjected::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_384_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveBoxProjected::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveBoxProjected G__TTEveBoxProjected;
static int G__G__Eve2_384_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[] (TEveBoxProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveBoxProjected*) (soff+(sizeof(TEveBoxProjected)*i)))->~G__TTEveBoxProjected();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveBoxProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveBoxProjected*) (soff))->~G__TTEveBoxProjected();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveBoxGL */
static int G__G__Eve2_385_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveBoxGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveBoxGL[n];
     } else {
       p = new((void*) gvp) TEveBoxGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveBoxGL;
     } else {
       p = new((void*) gvp) TEveBoxGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_385_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveBoxGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_385_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBoxGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_385_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveBoxGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_385_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveBoxGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_385_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBoxGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_385_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBoxGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_385_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveBoxGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_385_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBoxGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_385_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveBoxGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveBoxGL G__TTEveBoxGL;
static int G__G__Eve2_385_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[] (TEveBoxGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveBoxGL*) (soff+(sizeof(TEveBoxGL)*i)))->~G__TTEveBoxGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveBoxGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveBoxGL*) (soff))->~G__TTEveBoxGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveBoxProjectedGL */
static int G__G__Eve2_386_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveBoxProjectedGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveBoxProjectedGL[n];
     } else {
       p = new((void*) gvp) TEveBoxProjectedGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveBoxProjectedGL;
     } else {
       p = new((void*) gvp) TEveBoxProjectedGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjectedGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_386_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveBoxProjectedGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_386_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBoxProjectedGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_386_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveBoxProjectedGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_386_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveBoxProjectedGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_386_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBoxProjectedGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_386_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBoxProjectedGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_386_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveBoxProjectedGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_386_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBoxProjectedGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_386_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveBoxProjectedGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveBoxProjectedGL G__TTEveBoxProjectedGL;
static int G__G__Eve2_386_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[] (TEveBoxProjectedGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveBoxProjectedGL*) (soff+(sizeof(TEveBoxProjectedGL)*i)))->~G__TTEveBoxProjectedGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveBoxProjectedGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveBoxProjectedGL*) (soff))->~G__TTEveBoxProjectedGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveShape */
static int G__G__Eve2_390_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TEveShape*) G__getstructoffset())->GetFillColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TEveShape*) G__getstructoffset())->GetLineColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveShape*) G__getstructoffset())->GetLineWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveShape*) G__getstructoffset())->GetDrawFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveShape*) G__getstructoffset())->GetHighlightFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveShape*) G__getstructoffset())->GetMiniFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveShape*) G__getstructoffset())->SetFillColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveShape*) G__getstructoffset())->SetLineColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveShape*) G__getstructoffset())->SetLineWidth((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveShape*) G__getstructoffset())->SetDrawFrame((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveShape*) G__getstructoffset())->SetHighlightFrame((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveShape*) G__getstructoffset())->SetMiniFrame((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) TEveShape::FindConvexHull(*(TEveShape::vVector2_t*) libp->para[0].ref, *(TEveShape::vVector2_t*) libp->para[1].ref
, (TEveElement*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) TEveShape::FindConvexHull(*(TEveShape::vVector2_t*) libp->para[0].ref, *(TEveShape::vVector2_t*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TEveShape::IsBoxOrientationConsistentEv((TEveVector*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Float_t a[1][3]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      G__letint(result7, 103, (long) TEveShape::IsBoxOrientationConsistentFv(G__Ap0->a));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveShape::CheckAndFixBoxOrientationEv((TEveVector*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
  struct G__aRyp0 { Float_t a[1][3]; }* G__Ap0 = (struct G__aRyp0*) G__int(libp->para[0]);
      TEveShape::CheckAndFixBoxOrientationFv(G__Ap0->a);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveShape::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveShape::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveShape::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveShape::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveShape*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveShape::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveShape::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveShape::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_390_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveShape::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveShape G__TTEveShape;
static int G__G__Eve2_390_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[] (TEveShape*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveShape*) (soff+(sizeof(TEveShape)*i)))->~G__TTEveShape();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveShape*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveShape*) (soff))->~G__TTEveShape();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveShapeEditor */
static int G__G__Eve2_391_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveShapeEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveShapeEditor(
(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) TEveShapeEditor(
(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 TEveShapeEditor(
(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) TEveShapeEditor(
(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 TEveShapeEditor(
(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) TEveShapeEditor(
(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 TEveShapeEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveShapeEditor((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 TEveShapeEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveShapeEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveShapeEditor[n];
       } else {
         p = new((void*) gvp) TEveShapeEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveShapeEditor;
       } else {
         p = new((void*) gvp) TEveShapeEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveShapeEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_391_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveShapeEditor*) G__getstructoffset())->DoLineWidth();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_391_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveShapeEditor*) G__getstructoffset())->DoLineColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_391_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveShapeEditor*) G__getstructoffset())->DoDrawFrame();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_391_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveShapeEditor*) G__getstructoffset())->DoHighlightFrame();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_391_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveShapeEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_391_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveShapeEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_391_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveShapeEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_391_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveShapeEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_391_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveShapeEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_391_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveShapeEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_391_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveShapeEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_391_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveShapeEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_391_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveShapeEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveShapeEditor G__TTEveShapeEditor;
static int G__G__Eve2_391_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[] (TEveShapeEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveShapeEditor*) (soff+(sizeof(TEveShapeEditor)*i)))->~G__TTEveShapeEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveShapeEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveShapeEditor*) (soff))->~G__TTEveShapeEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveFrameBox */
static int G__G__Eve2_396_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveFrameBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveFrameBox[n];
     } else {
       p = new((void*) gvp) TEveFrameBox[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveFrameBox;
     } else {
       p = new((void*) gvp) TEveFrameBox;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveFrameBox*) G__getstructoffset())->SetAAQuadXY((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])
, (Float_t) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveFrameBox*) G__getstructoffset())->SetAAQuadXZ((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])
, (Float_t) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveFrameBox*) G__getstructoffset())->SetQuadByPoints((Float_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__Eve2_396_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveFrameBox*) G__getstructoffset())->SetAABox((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])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveFrameBox*) G__getstructoffset())->SetAABoxCenterHalfSize((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])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveFrameBox*) G__getstructoffset())->GetFrameType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveFrameBox*) G__getstructoffset())->GetFrameSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TEveFrameBox*) G__getstructoffset())->GetFramePoints());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveFrameBox*) G__getstructoffset())->GetFrameWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveFrameBox*) G__getstructoffset())->SetFrameWidth((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TEveFrameBox*) G__getstructoffset())->GetFrameColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 83, (long) ((TEveFrameBox*) G__getstructoffset())->PtrFrameColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 66, (long) ((TEveFrameBox*) G__getstructoffset())->GetFrameRGBA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveFrameBox*) G__getstructoffset())->SetFrameColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveFrameBox*) G__getstructoffset())->SetFrameColorPixel((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TEveFrameBox*) G__getstructoffset())->SetFrameColorRGBA((UChar_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]), (UChar_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TEveFrameBox*) G__getstructoffset())->SetFrameColorRGBA((UChar_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TEveFrameBox*) G__getstructoffset())->GetBackColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 83, (long) ((TEveFrameBox*) G__getstructoffset())->PtrBackColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 66, (long) ((TEveFrameBox*) G__getstructoffset())->GetBackRGBA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveFrameBox*) G__getstructoffset())->SetBackColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveFrameBox*) G__getstructoffset())->SetBackColorPixel((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TEveFrameBox*) G__getstructoffset())->SetBackColorRGBA((UChar_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]), (UChar_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TEveFrameBox*) G__getstructoffset())->SetBackColorRGBA((UChar_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveFrameBox*) G__getstructoffset())->GetFrameFill());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveFrameBox*) G__getstructoffset())->SetFrameFill((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveFrameBox*) G__getstructoffset())->GetDrawBack());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveFrameBox*) G__getstructoffset())->SetDrawBack((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveFrameBox::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveFrameBox::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveFrameBox::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveFrameBox::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveFrameBox*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveFrameBox::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveFrameBox::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveFrameBox::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_396_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveFrameBox::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveFrameBox G__TTEveFrameBox;
static int G__G__Eve2_396_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[] (TEveFrameBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveFrameBox*) (soff+(sizeof(TEveFrameBox)*i)))->~G__TTEveFrameBox();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveFrameBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveFrameBox*) (soff))->~G__TTEveFrameBox();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveFrameBoxGL */
static int G__G__Eve2_397_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveFrameBoxGL::Render((TEveFrameBox*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_397_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveFrameBoxGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_397_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveFrameBoxGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_397_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveFrameBoxGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_397_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveFrameBoxGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_397_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveFrameBoxGL*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_397_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveFrameBoxGL*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_397_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveFrameBoxGL*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_397_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveFrameBoxGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_397_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveFrameBoxGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_397_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveFrameBoxGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_397_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveFrameBoxGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_397_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveFrameBoxGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveFrameBoxGL G__TTEveFrameBoxGL;
static int G__G__Eve2_397_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[] (TEveFrameBoxGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveFrameBoxGL*) (soff+(sizeof(TEveFrameBoxGL)*i)))->~G__TTEveFrameBoxGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveFrameBoxGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveFrameBoxGL*) (soff))->~G__TTEveFrameBoxGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveRGBAPalette */
static int G__G__Eve2_399_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRGBAPalette* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRGBAPalette[n];
     } else {
       p = new((void*) gvp) TEveRGBAPalette[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRGBAPalette;
     } else {
       p = new((void*) gvp) TEveRGBAPalette;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRGBAPalette* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRGBAPalette(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TEveRGBAPalette(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRGBAPalette(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TEveRGBAPalette(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRGBAPalette(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveRGBAPalette(
(Int_t) G__int(libp->para[0]), (Int_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 TEveRGBAPalette((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveRGBAPalette((Int_t) G__int(libp->para[0]), (Int_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__Eve2LN_TEveRGBAPalette));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveRGBAPalette*) G__getstructoffset())->SetupColorArray();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->ClearColorArray();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveRGBAPalette*) G__getstructoffset())->WithinVisibleRange((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 66, (long) ((const TEveRGBAPalette*) G__getstructoffset())->ColorFromValue((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((const TEveRGBAPalette*) G__getstructoffset())->ColorFromValue((Int_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:
      ((const TEveRGBAPalette*) G__getstructoffset())->ColorFromValue((Int_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__Eve2_399_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) ((const TEveRGBAPalette*) G__getstructoffset())->ColorFromValue((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UChar_t*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) ((const TEveRGBAPalette*) G__getstructoffset())->ColorFromValue((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (UChar_t*) G__int(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveRGBAPalette*) G__getstructoffset())->GetMinVal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveRGBAPalette*) G__getstructoffset())->GetMaxVal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) 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__Eve2_399_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->SetLimitsScaleMinMax((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__Eve2_399_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->SetMinMax((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__Eve2_399_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->SetMin((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->SetMax((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveRGBAPalette*) G__getstructoffset())->GetLowLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveRGBAPalette*) G__getstructoffset())->GetHighLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveRGBAPalette*) G__getstructoffset())->GetInterpolate());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->SetInterpolate((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveRGBAPalette*) G__getstructoffset())->GetShowDefValue());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->SetShowDefValue((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveRGBAPalette*) G__getstructoffset())->GetFixColorRange());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->SetFixColorRange((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveRGBAPalette*) G__getstructoffset())->GetUnderflowAction());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveRGBAPalette*) G__getstructoffset())->GetOverflowAction());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->SetUnderflowAction((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->SetOverflowAction((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TEveRGBAPalette*) G__getstructoffset())->GetDefaultColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 83, (long) ((TEveRGBAPalette*) G__getstructoffset())->PtrDefaultColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 66, (long) ((TEveRGBAPalette*) G__getstructoffset())->GetDefaultRGBA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 66, (long) ((const TEveRGBAPalette*) G__getstructoffset())->GetDefaultRGBA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->SetDefaultColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->SetDefaultColorPixel((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TEveRGBAPalette*) G__getstructoffset())->SetDefaultColorRGBA((UChar_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]), (UChar_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TEveRGBAPalette*) G__getstructoffset())->SetDefaultColorRGBA((UChar_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TEveRGBAPalette*) G__getstructoffset())->GetUnderColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 83, (long) ((TEveRGBAPalette*) G__getstructoffset())->PtrUnderColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 66, (long) ((TEveRGBAPalette*) G__getstructoffset())->GetUnderRGBA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 66, (long) ((const TEveRGBAPalette*) G__getstructoffset())->GetUnderRGBA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->SetUnderColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->SetUnderColorPixel((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TEveRGBAPalette*) G__getstructoffset())->SetUnderColorRGBA((UChar_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]), (UChar_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TEveRGBAPalette*) G__getstructoffset())->SetUnderColorRGBA((UChar_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TEveRGBAPalette*) G__getstructoffset())->GetOverColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 83, (long) ((TEveRGBAPalette*) G__getstructoffset())->PtrOverColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 66, (long) ((TEveRGBAPalette*) G__getstructoffset())->GetOverRGBA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 66, (long) ((const TEveRGBAPalette*) G__getstructoffset())->GetOverRGBA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->SetOverColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->SetOverColorPixel((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TEveRGBAPalette*) G__getstructoffset())->SetOverColorRGBA((UChar_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]), (UChar_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TEveRGBAPalette*) G__getstructoffset())->SetOverColorRGBA((UChar_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->MinMaxValChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveRGBAPalette::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRGBAPalette::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveRGBAPalette::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveRGBAPalette::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPalette*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRGBAPalette::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRGBAPalette::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRGBAPalette::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_399_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRGBAPalette::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveRGBAPalette G__TTEveRGBAPalette;
static int G__G__Eve2_399_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveRGBAPalette*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveRGBAPalette*) (soff+(sizeof(TEveRGBAPalette)*i)))->~G__TTEveRGBAPalette();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveRGBAPalette*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveRGBAPalette*) (soff))->~G__TTEveRGBAPalette();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveRGBAPaletteEditor */
static int G__G__Eve2_400_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRGBAPaletteEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveRGBAPaletteEditor(
(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) TEveRGBAPaletteEditor(
(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 TEveRGBAPaletteEditor(
(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) TEveRGBAPaletteEditor(
(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 TEveRGBAPaletteEditor(
(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) TEveRGBAPaletteEditor(
(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 TEveRGBAPaletteEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveRGBAPaletteEditor((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 TEveRGBAPaletteEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveRGBAPaletteEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveRGBAPaletteEditor[n];
       } else {
         p = new((void*) gvp) TEveRGBAPaletteEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveRGBAPaletteEditor;
       } else {
         p = new((void*) gvp) TEveRGBAPaletteEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_400_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveRGBAPaletteEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_400_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRGBAPaletteEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_400_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveRGBAPaletteEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_400_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveRGBAPaletteEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_400_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPaletteEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_400_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRGBAPaletteEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_400_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRGBAPaletteEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_400_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRGBAPaletteEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_400_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRGBAPaletteEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveRGBAPaletteEditor G__TTEveRGBAPaletteEditor;
static int G__G__Eve2_400_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[] (TEveRGBAPaletteEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveRGBAPaletteEditor*) (soff+(sizeof(TEveRGBAPaletteEditor)*i)))->~G__TTEveRGBAPaletteEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveRGBAPaletteEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveRGBAPaletteEditor*) (soff))->~G__TTEveRGBAPaletteEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveRGBAPaletteSubEditor */
static int G__G__Eve2_401_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveRGBAPaletteSubEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveRGBAPaletteSubEditor((TGWindow*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveRGBAPaletteSubEditor((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__Eve2LN_TEveRGBAPaletteSubEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPaletteSubEditor*) G__getstructoffset())->SetModel((TEveRGBAPalette*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPaletteSubEditor*) G__getstructoffset())->Changed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPaletteSubEditor*) G__getstructoffset())->DoMinMax();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPaletteSubEditor*) G__getstructoffset())->DoInterpolate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPaletteSubEditor*) G__getstructoffset())->DoShowDefValue();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPaletteSubEditor*) G__getstructoffset())->DoDefaultColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPaletteSubEditor*) G__getstructoffset())->DoFixColorRange();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPaletteSubEditor*) G__getstructoffset())->DoUnderColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPaletteSubEditor*) G__getstructoffset())->DoOverColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPaletteSubEditor*) G__getstructoffset())->DoUnderflowAction((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPaletteSubEditor*) G__getstructoffset())->DoOverflowAction((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveRGBAPaletteSubEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRGBAPaletteSubEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveRGBAPaletteSubEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveRGBAPaletteSubEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveRGBAPaletteSubEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRGBAPaletteSubEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRGBAPaletteSubEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveRGBAPaletteSubEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_401_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveRGBAPaletteSubEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveRGBAPaletteSubEditor G__TTEveRGBAPaletteSubEditor;
static int G__G__Eve2_401_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[] (TEveRGBAPaletteSubEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveRGBAPaletteSubEditor*) (soff+(sizeof(TEveRGBAPaletteSubEditor)*i)))->~G__TTEveRGBAPaletteSubEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveRGBAPaletteSubEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveRGBAPaletteSubEditor*) (soff))->~G__TTEveRGBAPaletteSubEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveDigitSet */
static int G__G__Eve2_419_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->UseSingleColor();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveDigitSet*) G__getstructoffset())->GetAntiFlick());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->SetAntiFlick((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->RefitPlex();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->ScanMinMaxValues(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->SetCurrentDigit((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->DigitValue((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->DigitColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->DigitColor((Color_t) G__int(libp->para[0]), (Char_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TEveDigitSet*) G__getstructoffset())->DigitColor((UChar_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]), (UChar_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TEveDigitSet*) G__getstructoffset())->DigitColor((UChar_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->DigitColor((UChar_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveDigitSet*) G__getstructoffset())->GetOwnIds());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->SetOwnIds((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->DigitId((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->DigitUserData((void*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->DigitId((Int_t) G__int(libp->para[0]), (TObject*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->DigitUserData((Int_t) G__int(libp->para[0]), (void*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveDigitSet*) G__getstructoffset())->GetDigit((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveDigitSet*) G__getstructoffset())->GetId((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TEveDigitSet*) G__getstructoffset())->GetUserData((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->DigitSelected((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->SecSelected((TEveDigitSet*) 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__Eve2_419_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveDigitSet*) G__getstructoffset())->GetPlex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveDigitSet*) G__getstructoffset())->GetFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->SetFrame((TEveFrameBox*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveDigitSet*) G__getstructoffset())->GetValueIsColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveDigitSet*) G__getstructoffset())->GetPalette());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->SetPalette((TEveRGBAPalette*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveDigitSet*) G__getstructoffset())->AssertPalette());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveDigitSet*) G__getstructoffset())->GetRenderMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->SetRenderMode((TEveDigitSet::ERenderMode_e) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveDigitSet*) G__getstructoffset())->GetDisableLighting());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->SetDisableLighting((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveDigitSet*) G__getstructoffset())->GetHistoButtons());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->SetHistoButtons((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveDigitSet*) G__getstructoffset())->GetEmitSignals());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->SetEmitSignals((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TEveDigitSet*) G__getstructoffset())->GetCallbackFoo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->SetCallbackFoo((TEveDigitSet::Callback_foo) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TEveDigitSet*) G__getstructoffset())->GetTooltipCBFoo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->SetTooltipCBFoo((TEveDigitSet::TooltipCB_foo) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveDigitSet::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveDigitSet::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveDigitSet::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveDigitSet::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSet*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveDigitSet::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveDigitSet::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveDigitSet::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_419_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveDigitSet::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveDigitSet G__TTEveDigitSet;
static int G__G__Eve2_419_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveDigitSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveDigitSet*) (soff+(sizeof(TEveDigitSet)*i)))->~G__TTEveDigitSet();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveDigitSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveDigitSet*) (soff))->~G__TTEveDigitSet();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveDigitSetEditor */
static int G__G__Eve2_420_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveDigitSetEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveDigitSetEditor(
(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) TEveDigitSetEditor(
(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 TEveDigitSetEditor(
(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) TEveDigitSetEditor(
(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 TEveDigitSetEditor(
(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) TEveDigitSetEditor(
(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 TEveDigitSetEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveDigitSetEditor((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 TEveDigitSetEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveDigitSetEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveDigitSetEditor[n];
       } else {
         p = new((void*) gvp) TEveDigitSetEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveDigitSetEditor;
       } else {
         p = new((void*) gvp) TEveDigitSetEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_420_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSetEditor*) G__getstructoffset())->DoHisto();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_420_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSetEditor*) G__getstructoffset())->DoRangeHisto();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_420_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSetEditor*) G__getstructoffset())->PlotHisto((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__Eve2_420_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveDigitSetEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_420_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveDigitSetEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_420_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveDigitSetEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_420_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveDigitSetEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_420_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSetEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_420_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveDigitSetEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_420_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveDigitSetEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_420_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveDigitSetEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_420_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveDigitSetEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveDigitSetEditor G__TTEveDigitSetEditor;
static int G__G__Eve2_420_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[] (TEveDigitSetEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveDigitSetEditor*) (soff+(sizeof(TEveDigitSetEditor)*i)))->~G__TTEveDigitSetEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveDigitSetEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveDigitSetEditor*) (soff))->~G__TTEveDigitSetEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveDigitSetGL */
static int G__G__Eve2_421_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveDigitSetGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_421_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveDigitSetGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_421_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveDigitSetGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_421_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveDigitSetGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_421_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveDigitSetGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_421_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveDigitSetGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_421_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveDigitSetGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_421_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveDigitSetGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_421_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveDigitSetGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveDigitSetGL G__TTEveDigitSetGL;
static int G__G__Eve2_421_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[] (TEveDigitSetGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveDigitSetGL*) (soff+(sizeof(TEveDigitSetGL)*i)))->~G__TTEveDigitSetGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveDigitSetGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveDigitSetGL*) (soff))->~G__TTEveDigitSetGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveBoxSet */
static int G__G__Eve2_425_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveBoxSet* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveBoxSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveBoxSet((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 TEveBoxSet((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveBoxSet((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 TEveBoxSet[n];
       } else {
         p = new((void*) gvp) TEveBoxSet[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveBoxSet;
       } else {
         p = new((void*) gvp) TEveBoxSet;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSet));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBoxSet*) G__getstructoffset())->Reset((TEveBoxSet::EBoxType_e) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBoxSet*) G__getstructoffset())->Reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBoxSet*) G__getstructoffset())->AddBox((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBoxSet*) G__getstructoffset())->AddBox((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])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBoxSet*) G__getstructoffset())->AddBox((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__Eve2_425_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBoxSet*) G__getstructoffset())->AddCone(*(TEveVector*) libp->para[0].ref, *(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__Eve2_425_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TEveBoxSet*) G__getstructoffset())->AddEllipticCone(*(TEveVector*) libp->para[0].ref, *(TEveVector*) libp->para[1].ref
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TEveBoxSet*) G__getstructoffset())->AddEllipticCone(*(TEveVector*) libp->para[0].ref, *(TEveVector*) libp->para[1].ref
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBoxSet*) G__getstructoffset())->Test((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveBoxSet*) G__getstructoffset())->GetDefWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveBoxSet*) G__getstructoffset())->GetDefHeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveBoxSet*) G__getstructoffset())->GetDefDepth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveBoxSet*) G__getstructoffset())->GetDrawConeCap());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBoxSet*) G__getstructoffset())->SetDefWidth((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBoxSet*) G__getstructoffset())->SetDefHeight((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBoxSet*) G__getstructoffset())->SetDefDepth((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBoxSet*) G__getstructoffset())->SetDrawConeCap((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveBoxSet::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBoxSet::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveBoxSet::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveBoxSet::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBoxSet*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBoxSet::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveBoxSet::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBoxSet::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_425_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveBoxSet::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveBoxSet G__TTEveBoxSet;
static int G__G__Eve2_425_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveBoxSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveBoxSet*) (soff+(sizeof(TEveBoxSet)*i)))->~G__TTEveBoxSet();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveBoxSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveBoxSet*) (soff))->~G__TTEveBoxSet();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveBoxSetGL */
static int G__G__Eve2_426_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveBoxSetGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveBoxSetGL[n];
     } else {
       p = new((void*) gvp) TEveBoxSetGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveBoxSetGL;
     } else {
       p = new((void*) gvp) TEveBoxSetGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSetGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_426_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBoxSetGL*) G__getstructoffset())->Render(*(TGLRnrCtx*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_426_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveBoxSetGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_426_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBoxSetGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_426_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveBoxSetGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_426_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveBoxSetGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_426_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveBoxSetGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_426_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBoxSetGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_426_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveBoxSetGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_426_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveBoxSetGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_426_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveBoxSetGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveBoxSetGL G__TTEveBoxSetGL;
static int G__G__Eve2_426_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveBoxSetGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveBoxSetGL*) (soff+(sizeof(TEveBoxSetGL)*i)))->~G__TTEveBoxSetGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveBoxSetGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveBoxSetGL*) (soff))->~G__TTEveBoxSetGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCaloData */
static int G__G__Eve2_436_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveCaloData*) G__getstructoffset())->GetCellList((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])
, *(TEveCaloData::vCellId_t*) libp->para[4].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveCaloData::vCellId_t& obj = ((TEveCaloData*) G__getstructoffset())->GetCellsSelected();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveCaloData::vCellId_t& obj = ((TEveCaloData*) G__getstructoffset())->GetCellsHighlighted();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloData*) G__getstructoffset())->PrintCellsSelected();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloData*) G__getstructoffset())->ProcessSelection(*(TEveCaloData::vCellId_t*) libp->para[0].ref, *(TGLSelectRecord*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveCaloData*) G__getstructoffset())->Rebin((TAxis*) G__int(libp->para[0]), (TAxis*) G__int(libp->para[1])
, *(TEveCaloData::vCellId_t*) libp->para[2].ref, (Bool_t) G__int(libp->para[3])
, *(TEveCaloData::RebinData_t*) libp->para[4].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveCaloData*) G__getstructoffset())->GetCellData(*(TEveCaloData::CellId_t*) libp->para[0].ref, *(TEveCaloData::CellData_t*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloData*) G__getstructoffset())->InvalidateUsersCellIdCache();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloData*) G__getstructoffset())->DataChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloData*) G__getstructoffset())->CellSelectionChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveCaloData*) G__getstructoffset())->GetNSlices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveCaloData::SliceInfo_t& obj = ((TEveCaloData*) G__getstructoffset())->RefSliceInfo((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloData*) G__getstructoffset())->SetSliceThreshold((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__Eve2_436_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloData*) G__getstructoffset())->GetSliceThreshold((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloData*) G__getstructoffset())->SetSliceColor((Int_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__Eve2_436_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TEveCaloData*) G__getstructoffset())->GetSliceColor((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloData*) G__getstructoffset())->SetSliceTransparency((Int_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__Eve2_436_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((const TEveCaloData*) G__getstructoffset())->GetSliceTransparency((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveCaloData*) G__getstructoffset())->GetEtaLimits(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveCaloData*) G__getstructoffset())->GetPhiLimits(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloData*) G__getstructoffset())->GetMaxVal((Bool_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveCaloData*) G__getstructoffset())->Empty());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveCaloData*) G__getstructoffset())->GetEtaBins());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloData*) G__getstructoffset())->SetEtaBins((TAxis*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveCaloData*) G__getstructoffset())->GetPhiBins());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloData*) G__getstructoffset())->SetPhiBins((TAxis*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloData*) G__getstructoffset())->GetEps());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloData*) G__getstructoffset())->SetEps((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveCaloData*) G__getstructoffset())->GetWrapTwoPi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloData*) G__getstructoffset())->SetWrapTwoPi((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) TEveCaloData::EtaToTheta((Float_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCaloData::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloData::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCaloData::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCaloData::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloData*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloData::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloData::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloData::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_436_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloData::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCaloData G__TTEveCaloData;
static int G__G__Eve2_436_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveCaloData*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCaloData*) (soff+(sizeof(TEveCaloData)*i)))->~G__TTEveCaloData();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCaloData*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCaloData*) (soff))->~G__TTEveCaloData();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCaloData::SliceInfo_t */
static int G__G__Eve2_437_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCaloData::SliceInfo_t* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCaloData::SliceInfo_t[n];
     } else {
       p = new((void*) gvp) TEveCaloData::SliceInfo_t[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCaloData::SliceInfo_t;
     } else {
       p = new((void*) gvp) TEveCaloData::SliceInfo_t;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDatacLcLSliceInfo_t));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_437_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TEveCaloData::SliceInfo_t*) G__getstructoffset())->Setup((const char*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Color_t) G__int(libp->para[2]), (Char_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TEveCaloData::SliceInfo_t*) G__getstructoffset())->Setup((const char*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Color_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_437_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCaloData::SliceInfo_t::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_437_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloData::SliceInfo_t::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_437_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCaloData::SliceInfo_t::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_437_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCaloData::SliceInfo_t::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_437_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveCaloData::SliceInfo_t*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_437_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloData::SliceInfo_t*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_437_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloData::SliceInfo_t*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_437_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloData::SliceInfo_t*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_437_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloData::SliceInfo_t::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_437_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloData::SliceInfo_t::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_437_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloData::SliceInfo_t::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_437_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloData::SliceInfo_t::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve2_437_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveCaloData::SliceInfo_t* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveCaloData::SliceInfo_t(*(TEveCaloData::SliceInfo_t*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDatacLcLSliceInfo_t));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCaloData::SliceInfo_t G__TTEveCaloDatacLcLSliceInfo_t;
static int G__G__Eve2_437_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[] (TEveCaloData::SliceInfo_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCaloData::SliceInfo_t*) (soff+(sizeof(TEveCaloData::SliceInfo_t)*i)))->~G__TTEveCaloDatacLcLSliceInfo_t();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCaloData::SliceInfo_t*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCaloData::SliceInfo_t*) (soff))->~G__TTEveCaloDatacLcLSliceInfo_t();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve2_437_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCaloData::SliceInfo_t* dest = (TEveCaloData::SliceInfo_t*) G__getstructoffset();
   *dest = *(TEveCaloData::SliceInfo_t*) libp->para[0].ref;
   const TEveCaloData::SliceInfo_t& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCaloDataVec */
static int G__G__Eve2_461_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCaloDataVec* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveCaloDataVec((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveCaloDataVec((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataVec));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_461_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEveCaloDataVec*) G__getstructoffset())->AddSlice());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_461_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEveCaloDataVec*) G__getstructoffset())->AddTower((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__Eve2_461_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloDataVec*) G__getstructoffset())->FillSlice((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__Eve2_461_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloDataVec*) G__getstructoffset())->FillSlice((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__Eve2_461_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEveCaloDataVec*) G__getstructoffset())->GetNCells());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_461_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Float_t>& obj = ((TEveCaloDataVec*) G__getstructoffset())->GetSliceVals((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_461_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TEveCaloData::CellGeom_t>& obj = ((TEveCaloDataVec*) G__getstructoffset())->GetCellGeom();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_461_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEveCaloDataVec*) G__getstructoffset())->SetAxisFromBins((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveCaloDataVec*) G__getstructoffset())->SetAxisFromBins((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveCaloDataVec*) G__getstructoffset())->SetAxisFromBins();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_461_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCaloDataVec::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_461_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloDataVec::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_461_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCaloDataVec::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_461_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCaloDataVec::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_461_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloDataVec*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_461_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloDataVec::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_461_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloDataVec::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_461_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloDataVec::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_461_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloDataVec::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCaloDataVec G__TTEveCaloDataVec;
static int G__G__Eve2_461_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[] (TEveCaloDataVec*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCaloDataVec*) (soff+(sizeof(TEveCaloDataVec)*i)))->~G__TTEveCaloDataVec();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCaloDataVec*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCaloDataVec*) (soff))->~G__TTEveCaloDataVec();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCaloDataHist */
static int G__G__Eve2_466_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCaloDataHist* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCaloDataHist[n];
     } else {
       p = new((void*) gvp) TEveCaloDataHist[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCaloDataHist;
     } else {
       p = new((void*) gvp) TEveCaloDataHist;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataHist));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_466_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveCaloDataHist*) G__getstructoffset())->GetStack());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_466_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveCaloDataHist*) G__getstructoffset())->GetHist((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_466_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEveCaloDataHist*) G__getstructoffset())->AddHistogram((TH2F*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_466_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCaloDataHist::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_466_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloDataHist::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_466_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCaloDataHist::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_466_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCaloDataHist::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_466_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloDataHist*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_466_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloDataHist::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_466_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloDataHist::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_466_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloDataHist::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_466_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloDataHist::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCaloDataHist G__TTEveCaloDataHist;
static int G__G__Eve2_466_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[] (TEveCaloDataHist*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCaloDataHist*) (soff+(sizeof(TEveCaloDataHist)*i)))->~G__TTEveCaloDataHist();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCaloDataHist*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCaloDataHist*) (soff))->~G__TTEveCaloDataHist();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCaloViz */
static int G__G__Eve2_478_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloViz*) G__getstructoffset())->GetValToHeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->CellSelectionChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->SetScaleAbs((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveCaloViz*) G__getstructoffset())->GetData());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->SetData((TEveCaloData*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->DataChanged();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloViz*) G__getstructoffset())->GetMaxVal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveCaloViz*) G__getstructoffset())->AssertCellIdCache());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->InvalidateCellIdCache();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloViz*) G__getstructoffset())->GetDataSliceThreshold((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->SetDataSliceThreshold((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__Eve2_478_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TEveCaloViz*) G__getstructoffset())->GetDataSliceColor((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->SetDataSliceColor((Int_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__Eve2_478_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloViz*) G__getstructoffset())->GetBarrelRadius());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->SetBarrelRadius((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloViz*) G__getstructoffset())->GetEndCapPos());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->SetEndCapPos((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveCaloViz*) G__getstructoffset())->GetPlotEt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->SetPlotEt((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->SetMaxTowerH((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloViz*) G__getstructoffset())->GetMaxTowerH());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveCaloViz*) G__getstructoffset())->GetScaleAbs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->SetMaxValAbs((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloViz*) G__getstructoffset())->GetMaxValAbs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloViz*) G__getstructoffset())->GetTransitionEta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloViz*) G__getstructoffset())->GetTransitionTheta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveCaloViz*) G__getstructoffset())->GetPalette());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->SetPalette((TEveRGBAPalette*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveCaloViz*) G__getstructoffset())->AssertPalette());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveCaloViz*) G__getstructoffset())->GetValueIsColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->SetValueIsColor((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveCaloViz*) G__getstructoffset())->GetAutoRange());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->SetAutoRange((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->SetEta((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloViz*) G__getstructoffset())->GetEta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloViz*) G__getstructoffset())->GetEtaMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloViz*) G__getstructoffset())->GetEtaMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloViz*) G__getstructoffset())->GetEtaRng());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->SetPhi((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->SetPhiRng((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->SetPhiWithRng((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloViz*) G__getstructoffset())->GetPhi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloViz*) G__getstructoffset())->GetPhiMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloViz*) G__getstructoffset())->GetPhiMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloViz*) G__getstructoffset())->GetPhiRng());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveCaloViz*) G__getstructoffset())->CellInEtaPhiRng(*(TEveCaloData::CellData_t*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCaloViz::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloViz::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCaloViz::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCaloViz::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloViz*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloViz::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloViz::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloViz::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_478_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloViz::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCaloViz G__TTEveCaloViz;
static int G__G__Eve2_478_0_69(G__value* result7, G__CONST 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[] (TEveCaloViz*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCaloViz*) (soff+(sizeof(TEveCaloViz)*i)))->~G__TTEveCaloViz();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCaloViz*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCaloViz*) (soff))->~G__TTEveCaloViz();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCaloVizEditor */
static int G__G__Eve2_479_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCaloVizEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCaloVizEditor(
(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) TEveCaloVizEditor(
(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 TEveCaloVizEditor(
(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) TEveCaloVizEditor(
(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 TEveCaloVizEditor(
(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) TEveCaloVizEditor(
(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 TEveCaloVizEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveCaloVizEditor((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 TEveCaloVizEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveCaloVizEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveCaloVizEditor[n];
       } else {
         p = new((void*) gvp) TEveCaloVizEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveCaloVizEditor;
       } else {
         p = new((void*) gvp) TEveCaloVizEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloVizEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloVizEditor*) G__getstructoffset())->DoMaxTowerH();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloVizEditor*) G__getstructoffset())->DoScaleAbs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloVizEditor*) G__getstructoffset())->DoMaxValAbs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloVizEditor*) G__getstructoffset())->DoPlot();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloVizEditor*) G__getstructoffset())->DoEtaRange();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloVizEditor*) G__getstructoffset())->DoPhi();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloVizEditor*) G__getstructoffset())->DoSliceThreshold();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloVizEditor*) G__getstructoffset())->DoSliceColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloVizEditor*) G__getstructoffset())->DoSliceTransparency((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCaloVizEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloVizEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCaloVizEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCaloVizEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloVizEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloVizEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloVizEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloVizEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_479_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloVizEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCaloVizEditor G__TTEveCaloVizEditor;
static int G__G__Eve2_479_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[] (TEveCaloVizEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCaloVizEditor*) (soff+(sizeof(TEveCaloVizEditor)*i)))->~G__TTEveCaloVizEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCaloVizEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCaloVizEditor*) (soff))->~G__TTEveCaloVizEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCalo3D */
static int G__G__Eve2_480_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCalo3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCalo3D(
(TEveCaloData*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveCalo3D(
(TEveCaloData*) 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 TEveCalo3D((TEveCaloData*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveCalo3D((TEveCaloData*) 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 TEveCalo3D((TEveCaloData*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveCalo3D((TEveCaloData*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveCalo3D[n];
       } else {
         p = new((void*) gvp) TEveCalo3D[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveCalo3D;
       } else {
         p = new((void*) gvp) TEveCalo3D;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCalo3D*) G__getstructoffset())->SetFrameWidth((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCalo3D*) G__getstructoffset())->GetFrameWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCalo3D*) G__getstructoffset())->SetRnrFrame((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__Eve2_480_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveCalo3D*) G__getstructoffset())->GetRnrFrame(*(Bool_t*) G__Boolref(&libp->para[0]), *(Bool_t*) G__Boolref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCalo3D*) G__getstructoffset())->SetRnrEndCapFrame((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCalo3D*) G__getstructoffset())->SetRnrBarrelFrame((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveCalo3D*) G__getstructoffset())->GetRnrEndCapFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveCalo3D*) G__getstructoffset())->GetRnrBarrelFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCalo3D*) G__getstructoffset())->SetFrameTransparency((Char_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((const TEveCalo3D*) G__getstructoffset())->GetFrameTransparency());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCalo3D::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCalo3D::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCalo3D::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCalo3D::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCalo3D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCalo3D::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCalo3D::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCalo3D::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_480_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCalo3D::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCalo3D G__TTEveCalo3D;
static int G__G__Eve2_480_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[] (TEveCalo3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCalo3D*) (soff+(sizeof(TEveCalo3D)*i)))->~G__TTEveCalo3D();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCalo3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCalo3D*) (soff))->~G__TTEveCalo3D();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCalo3DGL */
static int G__G__Eve2_481_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCalo3DGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCalo3DGL[n];
     } else {
       p = new((void*) gvp) TEveCalo3DGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCalo3DGL;
     } else {
       p = new((void*) gvp) TEveCalo3DGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_481_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCalo3DGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_481_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCalo3DGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_481_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCalo3DGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_481_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCalo3DGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_481_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCalo3DGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_481_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCalo3DGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_481_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCalo3DGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_481_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCalo3DGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_481_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCalo3DGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCalo3DGL G__TTEveCalo3DGL;
static int G__G__Eve2_481_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveCalo3DGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCalo3DGL*) (soff+(sizeof(TEveCalo3DGL)*i)))->~G__TTEveCalo3DGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCalo3DGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCalo3DGL*) (soff))->~G__TTEveCalo3DGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCalo2D */
static int G__G__Eve2_482_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCalo2D* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCalo2D((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveCalo2D((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 TEveCalo2D((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveCalo2D((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 TEveCalo2D[n];
       } else {
         p = new((void*) gvp) TEveCalo2D[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveCalo2D;
       } else {
         p = new((void*) gvp) TEveCalo2D;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_482_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCalo2D::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_482_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCalo2D::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_482_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCalo2D::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_482_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCalo2D::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_482_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCalo2D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_482_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCalo2D::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_482_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCalo2D::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_482_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCalo2D::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_482_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCalo2D::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCalo2D G__TTEveCalo2D;
static int G__G__Eve2_482_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[] (TEveCalo2D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCalo2D*) (soff+(sizeof(TEveCalo2D)*i)))->~G__TTEveCalo2D();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCalo2D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCalo2D*) (soff))->~G__TTEveCalo2D();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCalo2DGL */
static int G__G__Eve2_483_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCalo2DGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCalo2DGL[n];
     } else {
       p = new((void*) gvp) TEveCalo2DGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCalo2DGL;
     } else {
       p = new((void*) gvp) TEveCalo2DGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2DGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_483_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCalo2DGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_483_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCalo2DGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_483_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCalo2DGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_483_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCalo2DGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_483_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCalo2DGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_483_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCalo2DGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_483_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCalo2DGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_483_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCalo2DGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_483_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCalo2DGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCalo2DGL G__TTEveCalo2DGL;
static int G__G__Eve2_483_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[] (TEveCalo2DGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCalo2DGL*) (soff+(sizeof(TEveCalo2DGL)*i)))->~G__TTEveCalo2DGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCalo2DGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCalo2DGL*) (soff))->~G__TTEveCalo2DGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCaloLego */
static int G__G__Eve2_488_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCaloLego* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCaloLego(
(TEveCaloData*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveCaloLego(
(TEveCaloData*) 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 TEveCaloLego((TEveCaloData*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveCaloLego((TEveCaloData*) 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 TEveCaloLego((TEveCaloData*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveCaloLego((TEveCaloData*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveCaloLego[n];
       } else {
         p = new((void*) gvp) TEveCaloLego[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveCaloLego;
       } else {
         p = new((void*) gvp) TEveCaloLego;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TEveCaloLego*) G__getstructoffset())->GetFontColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->SetFontColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TEveCaloLego*) G__getstructoffset())->GetGridColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->SetGridColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TEveCaloLego*) G__getstructoffset())->GetPlaneColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->SetPlaneColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((const TEveCaloLego*) G__getstructoffset())->GetPlaneTransparency());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->SetPlaneTransparency((Char_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveCaloLego*) G__getstructoffset())->GetNZSteps());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->SetNZSteps((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveCaloLego*) G__getstructoffset())->GetPixelsPerBin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->SetPixelsPerBin((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveCaloLego*) G__getstructoffset())->GetAutoRebin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->SetAutoRebin((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveCaloLego*) G__getstructoffset())->GetNormalizeRebin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->SetNormalizeRebin((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveCaloLego*) G__getstructoffset())->GetProjection());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->SetProjection((TEveCaloLego::EProjection_e) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->Set2DMode((TEveCaloLego::E2DMode_e) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEveCaloLego*) G__getstructoffset())->Get2DMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveCaloLego*) G__getstructoffset())->GetHasFixedHeightIn2DMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->SetHasFixedHeightIn2DMode((bool) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloLego*) G__getstructoffset())->GetFixedHeightValIn2DMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->SetFixedHeightValIn2DMode((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->SetBoxMode((TEveCaloLego::EBoxMode_e) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEveCaloLego*) G__getstructoffset())->GetBoxMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveCaloLego*) G__getstructoffset())->GetDrawHPlane());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->SetDrawHPlane((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveCaloLego*) G__getstructoffset())->GetHPlaneVal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->SetHPlaneVal((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEveCaloLego*) G__getstructoffset())->GetDrawNumberCellPixels());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->SetDrawNumberCellPixels((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEveCaloLego*) G__getstructoffset())->GetCellPixelFontSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->SetCellPixelFontSize((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCaloLego::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloLego::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCaloLego::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCaloLego::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLego*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloLego::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloLego::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloLego::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_488_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloLego::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCaloLego G__TTEveCaloLego;
static int G__G__Eve2_488_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[] (TEveCaloLego*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCaloLego*) (soff+(sizeof(TEveCaloLego)*i)))->~G__TTEveCaloLego();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCaloLego*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCaloLego*) (soff))->~G__TTEveCaloLego();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCaloLegoGL */
static int G__G__Eve2_489_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCaloLegoGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCaloLegoGL[n];
     } else {
       p = new((void*) gvp) TEveCaloLegoGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCaloLegoGL;
     } else {
       p = new((void*) gvp) TEveCaloLegoGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_489_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCaloLegoGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_489_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloLegoGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_489_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCaloLegoGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_489_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCaloLegoGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_489_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_489_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloLegoGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_489_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloLegoGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_489_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloLegoGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_489_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloLegoGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCaloLegoGL G__TTEveCaloLegoGL;
static int G__G__Eve2_489_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[] (TEveCaloLegoGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCaloLegoGL*) (soff+(sizeof(TEveCaloLegoGL)*i)))->~G__TTEveCaloLegoGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCaloLegoGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCaloLegoGL*) (soff))->~G__TTEveCaloLegoGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCaloLegoOverlay */
static int G__G__Eve2_490_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCaloLegoOverlay* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCaloLegoOverlay[n];
     } else {
       p = new((void*) gvp) TEveCaloLegoOverlay[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCaloLegoOverlay;
     } else {
       p = new((void*) gvp) TEveCaloLegoOverlay;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoOverlay));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveCaloLegoOverlay*) G__getstructoffset())->GetCaloLego());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoOverlay*) G__getstructoffset())->SetCaloLego((TEveCaloLego*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoOverlay*) G__getstructoffset())->SetShowPlane((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveCaloLegoOverlay*) G__getstructoffset())->GetShowPlane());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoOverlay*) G__getstructoffset())->SetHeaderTxt((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TEveCaloLegoOverlay*) G__getstructoffset())->GetHeaderTxt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoOverlay*) G__getstructoffset())->SetShowScales((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoOverlay*) G__getstructoffset())->SetScaleColorTransparency((Color_t) G__int(libp->para[0]), (Char_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoOverlay*) G__getstructoffset())->SetScalePosition((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoOverlay*) G__getstructoffset())->SetFrameAttribs((Color_t) G__int(libp->para[0]), (Char_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__Eve2_490_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCaloLegoOverlay::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloLegoOverlay::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCaloLegoOverlay::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCaloLegoOverlay::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoOverlay*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloLegoOverlay::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloLegoOverlay::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloLegoOverlay::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_490_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloLegoOverlay::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCaloLegoOverlay G__TTEveCaloLegoOverlay;
static int G__G__Eve2_490_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveCaloLegoOverlay*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCaloLegoOverlay*) (soff+(sizeof(TEveCaloLegoOverlay)*i)))->~G__TTEveCaloLegoOverlay();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCaloLegoOverlay*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCaloLegoOverlay*) (soff))->~G__TTEveCaloLegoOverlay();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCaloLegoEditor */
static int G__G__Eve2_499_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCaloLegoEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCaloLegoEditor(
(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) TEveCaloLegoEditor(
(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 TEveCaloLegoEditor(
(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) TEveCaloLegoEditor(
(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 TEveCaloLegoEditor(
(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) TEveCaloLegoEditor(
(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 TEveCaloLegoEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveCaloLegoEditor((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 TEveCaloLegoEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveCaloLegoEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveCaloLegoEditor[n];
       } else {
         p = new((void*) gvp) TEveCaloLegoEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveCaloLegoEditor;
       } else {
         p = new((void*) gvp) TEveCaloLegoEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoEditor*) G__getstructoffset())->DoGridColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoEditor*) G__getstructoffset())->DoFontColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoEditor*) G__getstructoffset())->DoPlaneColor((Pixel_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoEditor*) G__getstructoffset())->DoTransparency();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoEditor*) G__getstructoffset())->DoProjection();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoEditor*) G__getstructoffset())->Do2DMode();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoEditor*) G__getstructoffset())->DoBoxMode();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoEditor*) G__getstructoffset())->DoCell2DTextMin();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoEditor*) G__getstructoffset())->DoAutoRebin();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoEditor*) G__getstructoffset())->DoPixelsPerBin();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoEditor*) G__getstructoffset())->DoNormalize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCaloLegoEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloLegoEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCaloLegoEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCaloLegoEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCaloLegoEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloLegoEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloLegoEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCaloLegoEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_499_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCaloLegoEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCaloLegoEditor G__TTEveCaloLegoEditor;
static int G__G__Eve2_499_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[] (TEveCaloLegoEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCaloLegoEditor*) (soff+(sizeof(TEveCaloLegoEditor)*i)))->~G__TTEveCaloLegoEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCaloLegoEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCaloLegoEditor*) (soff))->~G__TTEveCaloLegoEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveCalo3DEditor */
static int G__G__Eve2_561_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveCalo3DEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveCalo3DEditor(
(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) TEveCalo3DEditor(
(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 TEveCalo3DEditor(
(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) TEveCalo3DEditor(
(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 TEveCalo3DEditor(
(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) TEveCalo3DEditor(
(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 TEveCalo3DEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveCalo3DEditor((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 TEveCalo3DEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveCalo3DEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveCalo3DEditor[n];
       } else {
         p = new((void*) gvp) TEveCalo3DEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveCalo3DEditor;
       } else {
         p = new((void*) gvp) TEveCalo3DEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_561_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCalo3DEditor*) G__getstructoffset())->DoFrameTransparency();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_561_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveCalo3DEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_561_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCalo3DEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_561_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveCalo3DEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_561_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveCalo3DEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_561_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveCalo3DEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_561_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCalo3DEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_561_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCalo3DEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_561_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveCalo3DEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_561_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveCalo3DEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveCalo3DEditor G__TTEveCalo3DEditor;
static int G__G__Eve2_561_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[] (TEveCalo3DEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveCalo3DEditor*) (soff+(sizeof(TEveCalo3DEditor)*i)))->~G__TTEveCalo3DEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveCalo3DEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveCalo3DEditor*) (soff))->~G__TTEveCalo3DEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGeoNode */
static int G__G__Eve2_563_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGeoNode* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveGeoNode((TGeoNode*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveGeoNode((TGeoNode*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNode));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveGeoNode*) G__getstructoffset())->GetNode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoNode*) G__getstructoffset())->ExpandIntoListTrees();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoNode*) G__getstructoffset())->ExpandIntoListTreesRecursively();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoNode*) G__getstructoffset())->UpdateNode((TGeoNode*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoNode*) G__getstructoffset())->UpdateVolume((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TEveGeoNode*) G__getstructoffset())->Save((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TEveGeoNode*) G__getstructoffset())->Save((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveGeoNode*) G__getstructoffset())->Save((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoNode*) G__getstructoffset())->SaveExtract((const char*) G__int(libp->para[0]), (const char*) 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__Eve2_563_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoNode*) G__getstructoffset())->WriteExtract((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoNode::GetCSGExportNSeg());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGeoNode::SetCSGExportNSeg((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGeoNode::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoNode::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGeoNode::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGeoNode::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoNode*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoNode::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoNode::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoNode::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_563_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoNode::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGeoNode G__TTEveGeoNode;
static int G__G__Eve2_563_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveGeoNode*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGeoNode*) (soff+(sizeof(TEveGeoNode)*i)))->~G__TTEveGeoNode();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGeoNode*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGeoNode*) (soff))->~G__TTEveGeoNode();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGeoTopNode */
static int G__G__Eve2_564_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGeoTopNode* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGeoTopNode(
(TGeoManager*) G__int(libp->para[0]), (TGeoNode*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TEveGeoTopNode(
(TGeoManager*) G__int(libp->para[0]), (TGeoNode*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGeoTopNode(
(TGeoManager*) G__int(libp->para[0]), (TGeoNode*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TEveGeoTopNode(
(TGeoManager*) G__int(libp->para[0]), (TGeoNode*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGeoTopNode(
(TGeoManager*) G__int(libp->para[0]), (TGeoNode*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveGeoTopNode(
(TGeoManager*) G__int(libp->para[0]), (TGeoNode*) 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 TEveGeoTopNode((TGeoManager*) G__int(libp->para[0]), (TGeoNode*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveGeoTopNode((TGeoManager*) G__int(libp->para[0]), (TGeoNode*) 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__Eve2LN_TEveGeoTopNode));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoTopNode*) G__getstructoffset())->UseNodeTrans();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveGeoTopNode*) G__getstructoffset())->GetGeoManager());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveGeoTopNode*) G__getstructoffset())->GetVisOption());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoTopNode*) G__getstructoffset())->SetVisOption((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveGeoTopNode*) G__getstructoffset())->GetVisLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoTopNode*) G__getstructoffset())->SetVisLevel((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveGeoTopNode*) G__getstructoffset())->GetMaxVisNodes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoTopNode*) G__getstructoffset())->SetMaxVisNodes((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoTopNode*) G__getstructoffset())->VolumeVisChanged((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoTopNode*) G__getstructoffset())->VolumeColChanged((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoTopNode*) G__getstructoffset())->NodeVisChanged((TGeoNode*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGeoTopNode::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoTopNode::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGeoTopNode::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGeoTopNode::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoTopNode*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoTopNode::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoTopNode::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoTopNode::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_564_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoTopNode::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGeoTopNode G__TTEveGeoTopNode;
static int G__G__Eve2_564_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[] (TEveGeoTopNode*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGeoTopNode*) (soff+(sizeof(TEveGeoTopNode)*i)))->~G__TTEveGeoTopNode();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGeoTopNode*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGeoTopNode*) (soff))->~G__TTEveGeoTopNode();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGeoNodeEditor */
static int G__G__Eve2_565_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGeoNodeEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGeoNodeEditor(
(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) TEveGeoNodeEditor(
(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 TEveGeoNodeEditor(
(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) TEveGeoNodeEditor(
(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 TEveGeoNodeEditor(
(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) TEveGeoNodeEditor(
(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 TEveGeoNodeEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveGeoNodeEditor((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 TEveGeoNodeEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveGeoNodeEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGeoNodeEditor[n];
       } else {
         p = new((void*) gvp) TEveGeoNodeEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGeoNodeEditor;
       } else {
         p = new((void*) gvp) TEveGeoNodeEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNodeEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_565_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoNodeEditor*) G__getstructoffset())->DoVizNode();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_565_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoNodeEditor*) G__getstructoffset())->DoVizNodeDaughters();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_565_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoNodeEditor*) G__getstructoffset())->DoVizVolume();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_565_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoNodeEditor*) G__getstructoffset())->DoVizVolumeDaughters();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_565_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGeoNodeEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_565_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoNodeEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_565_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGeoNodeEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_565_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGeoNodeEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_565_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoNodeEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_565_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoNodeEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_565_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoNodeEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_565_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoNodeEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_565_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoNodeEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGeoNodeEditor G__TTEveGeoNodeEditor;
static int G__G__Eve2_565_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[] (TEveGeoNodeEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGeoNodeEditor*) (soff+(sizeof(TEveGeoNodeEditor)*i)))->~G__TTEveGeoNodeEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGeoNodeEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGeoNodeEditor*) (soff))->~G__TTEveGeoNodeEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGeoTopNodeEditor */
static int G__G__Eve2_566_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGeoTopNodeEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGeoTopNodeEditor(
(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) TEveGeoTopNodeEditor(
(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 TEveGeoTopNodeEditor(
(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) TEveGeoTopNodeEditor(
(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 TEveGeoTopNodeEditor(
(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) TEveGeoTopNodeEditor(
(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 TEveGeoTopNodeEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveGeoTopNodeEditor((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 TEveGeoTopNodeEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveGeoTopNodeEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGeoTopNodeEditor[n];
       } else {
         p = new((void*) gvp) TEveGeoTopNodeEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGeoTopNodeEditor;
       } else {
         p = new((void*) gvp) TEveGeoTopNodeEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNodeEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_566_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoTopNodeEditor*) G__getstructoffset())->DoVisOption();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_566_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoTopNodeEditor*) G__getstructoffset())->DoVisLevel();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_566_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoTopNodeEditor*) G__getstructoffset())->DoMaxVisNodes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_566_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGeoTopNodeEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_566_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoTopNodeEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_566_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGeoTopNodeEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_566_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGeoTopNodeEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_566_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoTopNodeEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_566_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoTopNodeEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_566_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoTopNodeEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_566_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoTopNodeEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_566_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoTopNodeEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGeoTopNodeEditor G__TTEveGeoTopNodeEditor;
static int G__G__Eve2_566_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[] (TEveGeoTopNodeEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGeoTopNodeEditor*) (soff+(sizeof(TEveGeoTopNodeEditor)*i)))->~G__TTEveGeoTopNodeEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGeoTopNodeEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGeoTopNodeEditor*) (soff))->~G__TTEveGeoTopNodeEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGeoShapeExtract */
static int G__G__Eve2_572_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGeoShapeExtract* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGeoShapeExtract((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveGeoShapeExtract((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 TEveGeoShapeExtract((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveGeoShapeExtract((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 TEveGeoShapeExtract[n];
       } else {
         p = new((void*) gvp) TEveGeoShapeExtract[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGeoShapeExtract;
       } else {
         p = new((void*) gvp) TEveGeoShapeExtract;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeExtract));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveGeoShapeExtract*) G__getstructoffset())->HasElements());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoShapeExtract*) G__getstructoffset())->AddElement((TEveGeoShapeExtract*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoShapeExtract*) G__getstructoffset())->SetTrans((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoShapeExtract*) G__getstructoffset())->SetRGBA((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoShapeExtract*) G__getstructoffset())->SetRGBALine((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoShapeExtract*) G__getstructoffset())->SetRnrSelf((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoShapeExtract*) G__getstructoffset())->SetRnrElements((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoShapeExtract*) G__getstructoffset())->SetRnrFrame((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoShapeExtract*) G__getstructoffset())->SetMiniFrame((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoShapeExtract*) G__getstructoffset())->SetShape((TGeoShape*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoShapeExtract*) G__getstructoffset())->SetElements((TList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TEveGeoShapeExtract*) G__getstructoffset())->GetTrans());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((TEveGeoShapeExtract*) G__getstructoffset())->GetRGBA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((TEveGeoShapeExtract*) G__getstructoffset())->GetRGBALine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveGeoShapeExtract*) G__getstructoffset())->GetRnrSelf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveGeoShapeExtract*) G__getstructoffset())->GetRnrElements());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveGeoShapeExtract*) G__getstructoffset())->GetRnrFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveGeoShapeExtract*) G__getstructoffset())->GetMiniFrame());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveGeoShapeExtract*) G__getstructoffset())->GetShape());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveGeoShapeExtract*) G__getstructoffset())->GetElements());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGeoShapeExtract::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoShapeExtract::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGeoShapeExtract::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGeoShapeExtract::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoShapeExtract*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoShapeExtract::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoShapeExtract::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoShapeExtract::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_572_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoShapeExtract::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGeoShapeExtract G__TTEveGeoShapeExtract;
static int G__G__Eve2_572_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveGeoShapeExtract*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGeoShapeExtract*) (soff+(sizeof(TEveGeoShapeExtract)*i)))->~G__TTEveGeoShapeExtract();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGeoShapeExtract*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGeoShapeExtract*) (soff))->~G__TTEveGeoShapeExtract();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGeoShape */
static int G__G__Eve2_573_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGeoShape* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGeoShape((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveGeoShape((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 TEveGeoShape((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveGeoShape((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 TEveGeoShape[n];
       } else {
         p = new((void*) gvp) TEveGeoShape[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGeoShape;
       } else {
         p = new((void*) gvp) TEveGeoShape;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShape));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveGeoShape*) G__getstructoffset())->GetNSegments());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveGeoShape*) G__getstructoffset())->GetShape());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoShape*) G__getstructoffset())->SetNSegments((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoShape*) G__getstructoffset())->SetShape((TGeoShape*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEveGeoShape*) G__getstructoffset())->Save((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveGeoShape*) G__getstructoffset())->Save((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoShape*) G__getstructoffset())->SaveExtract((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__Eve2_573_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoShape*) G__getstructoffset())->WriteExtract((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) TEveGeoShape::ImportShapeExtract((TEveGeoShapeExtract*) G__int(libp->para[0]), (TEveElement*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TEveGeoShape::ImportShapeExtract((TEveGeoShapeExtract*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveGeoShape*) G__getstructoffset())->MakeBuffer3D());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGeoShape::GetGeoMangeur());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGeoShape::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoShape::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGeoShape::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGeoShape::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoShape*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoShape::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoShape::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoShape::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_573_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoShape::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGeoShape G__TTEveGeoShape;
static int G__G__Eve2_573_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[] (TEveGeoShape*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGeoShape*) (soff+(sizeof(TEveGeoShape)*i)))->~G__TTEveGeoShape();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGeoShape*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGeoShape*) (soff))->~G__TTEveGeoShape();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGeoShapeProjected */
static int G__G__Eve2_574_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGeoShapeProjected* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGeoShapeProjected[n];
     } else {
       p = new((void*) gvp) TEveGeoShapeProjected[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGeoShapeProjected;
     } else {
       p = new((void*) gvp) TEveGeoShapeProjected;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeProjected));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_574_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGeoShapeProjected::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_574_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoShapeProjected::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_574_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGeoShapeProjected::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_574_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGeoShapeProjected::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_574_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoShapeProjected*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_574_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoShapeProjected::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_574_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoShapeProjected::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_574_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoShapeProjected::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_574_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoShapeProjected::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGeoShapeProjected G__TTEveGeoShapeProjected;
static int G__G__Eve2_574_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[] (TEveGeoShapeProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGeoShapeProjected*) (soff+(sizeof(TEveGeoShapeProjected)*i)))->~G__TTEveGeoShapeProjected();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGeoShapeProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGeoShapeProjected*) (soff))->~G__TTEveGeoShapeProjected();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGeoPolyShape */
static int G__G__Eve2_583_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGeoPolyShape* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGeoPolyShape[n];
     } else {
       p = new((void*) gvp) TEveGeoPolyShape[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGeoPolyShape;
     } else {
       p = new((void*) gvp) TEveGeoPolyShape;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoPolyShape));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_583_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGeoPolyShape::Construct((TGeoCompositeShape*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_583_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoPolyShape*) G__getstructoffset())->SetFromFaceSet((TGLFaceSet*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_583_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGeoPolyShape::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_583_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoPolyShape::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_583_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGeoPolyShape::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_583_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGeoPolyShape::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_583_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGeoPolyShape*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_583_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoPolyShape::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_583_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoPolyShape::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_583_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGeoPolyShape::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_583_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGeoPolyShape::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGeoPolyShape G__TTEveGeoPolyShape;
static int G__G__Eve2_583_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[] (TEveGeoPolyShape*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGeoPolyShape*) (soff+(sizeof(TEveGeoPolyShape)*i)))->~G__TTEveGeoPolyShape();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGeoPolyShape*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGeoPolyShape*) (soff))->~G__TTEveGeoPolyShape();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGridStepper */
static int G__G__Eve2_586_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGridStepper* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGridStepper((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveGridStepper((Int_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGridStepper[n];
       } else {
         p = new((void*) gvp) TEveGridStepper[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGridStepper;
       } else {
         p = new((void*) gvp) TEveGridStepper;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepper));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGridStepper*) G__getstructoffset())->Reset();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGridStepper*) G__getstructoffset())->Subtract(*(TEveGridStepper*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TEveGridStepper*) G__getstructoffset())->SetNs((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TEveGridStepper*) G__getstructoffset())->SetNs((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TEveGridStepper*) G__getstructoffset())->SetDs((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TEveGridStepper*) G__getstructoffset())->SetDs((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__Eve2_586_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TEveGridStepper*) G__getstructoffset())->SetOs((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TEveGridStepper*) G__getstructoffset())->SetOs((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__Eve2_586_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveGridStepper*) G__getstructoffset())->Step());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGridStepper*) G__getstructoffset())->GetPosition((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGridStepper*) G__getstructoffset())->SetTrans((TEveTrans*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGridStepper*) G__getstructoffset())->SetTransAdvance((TEveTrans*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveGridStepper*) G__getstructoffset())->GetCx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveGridStepper*) G__getstructoffset())->GetCy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveGridStepper*) G__getstructoffset())->GetCz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveGridStepper*) G__getstructoffset())->GetNx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveGridStepper*) G__getstructoffset())->GetNy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveGridStepper*) G__getstructoffset())->GetNz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveGridStepper*) G__getstructoffset())->GetDx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveGridStepper*) G__getstructoffset())->GetDy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveGridStepper*) G__getstructoffset())->GetDz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveGridStepper*) G__getstructoffset())->GetOx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveGridStepper*) G__getstructoffset())->GetOy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveGridStepper*) G__getstructoffset())->GetOz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGridStepper::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGridStepper::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGridStepper::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGridStepper::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGridStepper*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGridStepper::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGridStepper::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGridStepper::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_586_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGridStepper::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGridStepper G__TTEveGridStepper;
static int G__G__Eve2_586_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[] (TEveGridStepper*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGridStepper*) (soff+(sizeof(TEveGridStepper)*i)))->~G__TTEveGridStepper();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGridStepper*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGridStepper*) (soff))->~G__TTEveGridStepper();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGridStepperSubEditor */
static int G__G__Eve2_587_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGridStepperSubEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveGridStepperSubEditor((TGWindow*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveGridStepperSubEditor((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__Eve2LN_TEveGridStepperSubEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_587_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGridStepperSubEditor*) G__getstructoffset())->SetModel((TEveGridStepper*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_587_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGridStepperSubEditor*) G__getstructoffset())->Changed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_587_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGridStepperSubEditor*) G__getstructoffset())->DoNs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_587_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGridStepperSubEditor*) G__getstructoffset())->DoDs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_587_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGridStepperSubEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_587_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGridStepperSubEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_587_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGridStepperSubEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_587_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGridStepperSubEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_587_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGridStepperSubEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_587_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGridStepperSubEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_587_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGridStepperSubEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_587_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGridStepperSubEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_587_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGridStepperSubEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGridStepperSubEditor G__TTEveGridStepperSubEditor;
static int G__G__Eve2_587_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[] (TEveGridStepperSubEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGridStepperSubEditor*) (soff+(sizeof(TEveGridStepperSubEditor)*i)))->~G__TTEveGridStepperSubEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGridStepperSubEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGridStepperSubEditor*) (soff))->~G__TTEveGridStepperSubEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveGridStepperEditor */
static int G__G__Eve2_588_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveGridStepperEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveGridStepperEditor(
(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) TEveGridStepperEditor(
(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 TEveGridStepperEditor(
(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) TEveGridStepperEditor(
(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 TEveGridStepperEditor(
(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) TEveGridStepperEditor(
(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 TEveGridStepperEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveGridStepperEditor((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 TEveGridStepperEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveGridStepperEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGridStepperEditor[n];
       } else {
         p = new((void*) gvp) TEveGridStepperEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveGridStepperEditor;
       } else {
         p = new((void*) gvp) TEveGridStepperEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_588_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveGridStepperEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_588_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGridStepperEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_588_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveGridStepperEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_588_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveGridStepperEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_588_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveGridStepperEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_588_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGridStepperEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_588_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGridStepperEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_588_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveGridStepperEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_588_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveGridStepperEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveGridStepperEditor G__TTEveGridStepperEditor;
static int G__G__Eve2_588_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[] (TEveGridStepperEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveGridStepperEditor*) (soff+(sizeof(TEveGridStepperEditor)*i)))->~G__TTEveGridStepperEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveGridStepperEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveGridStepperEditor*) (soff))->~G__TTEveGridStepperEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveLegoEventHandler */
static int G__G__Eve2_593_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveLegoEventHandler* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveLegoEventHandler(
(TGWindow*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1])
, (TEveCaloLego*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveLegoEventHandler(
(TGWindow*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1])
, (TEveCaloLego*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveLegoEventHandler((TGWindow*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveLegoEventHandler((TGWindow*) G__int(libp->para[0]), (TObject*) 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__Eve2LN_TEveLegoEventHandler));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_593_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TEveLegoEventHandler*) G__getstructoffset())->GetTransTheta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_593_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveLegoEventHandler*) G__getstructoffset())->SetTransTheta((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_593_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveLegoEventHandler*) G__getstructoffset())->GetLego());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_593_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveLegoEventHandler*) G__getstructoffset())->SetLego((TEveCaloLego*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_593_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveLegoEventHandler::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_593_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveLegoEventHandler::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_593_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveLegoEventHandler::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_593_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveLegoEventHandler::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_593_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveLegoEventHandler*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_593_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveLegoEventHandler::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_593_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveLegoEventHandler::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_593_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveLegoEventHandler::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_593_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveLegoEventHandler::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveLegoEventHandler G__TTEveLegoEventHandler;
static int G__G__Eve2_593_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[] (TEveLegoEventHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveLegoEventHandler*) (soff+(sizeof(TEveLegoEventHandler)*i)))->~G__TTEveLegoEventHandler();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveLegoEventHandler*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveLegoEventHandler*) (soff))->~G__TTEveLegoEventHandler();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveLine */
static int G__G__Eve2_595_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveLine* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveLine((Int_t) G__int(libp->para[0]), (TEvePointSelectorConsumer::ETreeVarType_e) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveLine((Int_t) G__int(libp->para[0]), (TEvePointSelectorConsumer::ETreeVarType_e) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveLine((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveLine((Int_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveLine[n];
       } else {
         p = new((void*) gvp) TEveLine[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveLine;
       } else {
         p = new((void*) gvp) TEveLine;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveLine));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveLine* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveLine(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TEvePointSelectorConsumer::ETreeVarType_e) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveLine(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TEvePointSelectorConsumer::ETreeVarType_e) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveLine((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveLine((const char*) 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 TEveLine((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveLine((const char*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveLine));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveLine*) G__getstructoffset())->GetRnrLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveLine*) G__getstructoffset())->GetRnrPoints());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveLine*) G__getstructoffset())->GetSmooth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveLine*) G__getstructoffset())->SetRnrLine((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveLine*) G__getstructoffset())->SetRnrPoints((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveLine*) G__getstructoffset())->SetSmooth((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveLine*) G__getstructoffset())->ReduceSegmentLengths((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector* pobj;
         const TEveVector xobj = ((const TEveLine*) G__getstructoffset())->GetLineStart();
         pobj = new TEveVector(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__Eve2_595_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector* pobj;
         const TEveVector xobj = ((const TEveLine*) G__getstructoffset())->GetLineEnd();
         pobj = new TEveVector(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__Eve2_595_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TEveLine::GetDefaultSmooth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveLine::SetDefaultSmooth((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveLine::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveLine::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveLine::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveLine::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveLine*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveLine::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveLine::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveLine::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_595_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveLine::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveLine G__TTEveLine;
static int G__G__Eve2_595_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveLine*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveLine*) (soff+(sizeof(TEveLine)*i)))->~G__TTEveLine();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveLine*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveLine*) (soff))->~G__TTEveLine();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveLineEditor */
static int G__G__Eve2_596_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveLineEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveLineEditor(
(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) TEveLineEditor(
(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 TEveLineEditor(
(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) TEveLineEditor(
(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 TEveLineEditor(
(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) TEveLineEditor(
(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 TEveLineEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveLineEditor((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 TEveLineEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveLineEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveLineEditor[n];
       } else {
         p = new((void*) gvp) TEveLineEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveLineEditor;
       } else {
         p = new((void*) gvp) TEveLineEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveLineEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_596_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveLineEditor*) G__getstructoffset())->DoRnrLine();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_596_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveLineEditor*) G__getstructoffset())->DoRnrPoints();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_596_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveLineEditor*) G__getstructoffset())->DoSmooth();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_596_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveLineEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_596_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveLineEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_596_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveLineEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_596_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveLineEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_596_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveLineEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_596_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveLineEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_596_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveLineEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_596_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveLineEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_596_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveLineEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveLineEditor G__TTEveLineEditor;
static int G__G__Eve2_596_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[] (TEveLineEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveLineEditor*) (soff+(sizeof(TEveLineEditor)*i)))->~G__TTEveLineEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveLineEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveLineEditor*) (soff))->~G__TTEveLineEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveLineGL */
static int G__G__Eve2_598_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveLineGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveLineGL[n];
     } else {
       p = new((void*) gvp) TEveLineGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveLineGL;
     } else {
       p = new((void*) gvp) TEveLineGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveLineGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_598_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveLineGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_598_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveLineGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_598_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveLineGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_598_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveLineGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_598_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveLineGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_598_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveLineGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_598_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveLineGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_598_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveLineGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_598_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveLineGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveLineGL G__TTEveLineGL;
static int G__G__Eve2_598_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[] (TEveLineGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveLineGL*) (soff+(sizeof(TEveLineGL)*i)))->~G__TTEveLineGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveLineGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveLineGL*) (soff))->~G__TTEveLineGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvePointSet */
static int G__G__Eve2_622_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePointSet* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePointSet((Int_t) G__int(libp->para[0]), (TEvePointSelectorConsumer::ETreeVarType_e) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEvePointSet((Int_t) G__int(libp->para[0]), (TEvePointSelectorConsumer::ETreeVarType_e) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePointSet((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEvePointSet((Int_t) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEvePointSet[n];
       } else {
         p = new((void*) gvp) TEvePointSet[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEvePointSet;
       } else {
         p = new((void*) gvp) TEvePointSet;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePointSet* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePointSet(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TEvePointSelectorConsumer::ETreeVarType_e) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEvePointSet(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TEvePointSelectorConsumer::ETreeVarType_e) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePointSet((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEvePointSet((const char*) 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 TEvePointSet((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEvePointSet((const char*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePointSet* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEvePointSet(*(TEvePointSet*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEvePointSet(*(TEvePointSet*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSet*) G__getstructoffset())->ClonePoints(*(TEvePointSet*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEvePointSet*) G__getstructoffset())->Reset((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEvePointSet*) G__getstructoffset())->Reset((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEvePointSet*) G__getstructoffset())->Reset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TEvePointSet*) G__getstructoffset())->GrowFor((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSet*) G__getstructoffset())->SetTitle((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvePointSet*) G__getstructoffset())->GetIntIdsPerPoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TEvePointSet*) G__getstructoffset())->GetPointIntIds((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvePointSet*) G__getstructoffset())->GetPointIntId((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSet*) G__getstructoffset())->SetPointIntIds((Int_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSet*) G__getstructoffset())->SetPointIntIds((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__Eve2_622_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvePointSet::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSet::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvePointSet::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvePointSet::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSet*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSet::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePointSet::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSet::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_622_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePointSet::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvePointSet G__TTEvePointSet;
static int G__G__Eve2_622_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEvePointSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvePointSet*) (soff+(sizeof(TEvePointSet)*i)))->~G__TTEvePointSet();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvePointSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvePointSet*) (soff))->~G__TTEvePointSet();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvePointSetArray */
static int G__G__Eve2_623_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePointSetArray* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePointSetArray((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEvePointSetArray((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 TEvePointSetArray((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEvePointSetArray((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 TEvePointSetArray[n];
       } else {
         p = new((void*) gvp) TEvePointSetArray[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEvePointSetArray;
       } else {
         p = new((void*) gvp) TEvePointSetArray;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArray));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((const TEvePointSetArray*) G__getstructoffset())->Size((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((const TEvePointSetArray*) G__getstructoffset())->Size((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((const TEvePointSetArray*) G__getstructoffset())->Size());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSetArray*) G__getstructoffset())->InitBins((const char*) G__int(libp->para[0]), (Int_t) G__int(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__Eve2_623_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEvePointSetArray*) G__getstructoffset())->Fill((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSetArray*) G__getstructoffset())->SetPointId((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSetArray*) G__getstructoffset())->CloseBins();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSetArray*) G__getstructoffset())->SetOwnIds((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvePointSetArray*) G__getstructoffset())->GetDefPointSetCapacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSetArray*) G__getstructoffset())->SetDefPointSetCapacity((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEvePointSetArray*) G__getstructoffset())->GetNBins());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvePointSetArray*) G__getstructoffset())->GetBin((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvePointSetArray*) G__getstructoffset())->GetMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvePointSetArray*) G__getstructoffset())->GetCurMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvePointSetArray*) G__getstructoffset())->GetMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEvePointSetArray*) G__getstructoffset())->GetCurMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSetArray*) G__getstructoffset())->SetRange((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvePointSetArray::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSetArray::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvePointSetArray::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvePointSetArray::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSetArray*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSetArray::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePointSetArray::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSetArray::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_623_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePointSetArray::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvePointSetArray G__TTEvePointSetArray;
static int G__G__Eve2_623_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[] (TEvePointSetArray*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvePointSetArray*) (soff+(sizeof(TEvePointSetArray)*i)))->~G__TTEvePointSetArray();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvePointSetArray*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvePointSetArray*) (soff))->~G__TTEvePointSetArray();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvePointSetArrayEditor */
static int G__G__Eve2_624_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePointSetArrayEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePointSetArrayEditor(
(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) TEvePointSetArrayEditor(
(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 TEvePointSetArrayEditor(
(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) TEvePointSetArrayEditor(
(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 TEvePointSetArrayEditor(
(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) TEvePointSetArrayEditor(
(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 TEvePointSetArrayEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEvePointSetArrayEditor((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 TEvePointSetArrayEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEvePointSetArrayEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEvePointSetArrayEditor[n];
       } else {
         p = new((void*) gvp) TEvePointSetArrayEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEvePointSetArrayEditor;
       } else {
         p = new((void*) gvp) TEvePointSetArrayEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArrayEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_624_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSetArrayEditor*) G__getstructoffset())->DoRange();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_624_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvePointSetArrayEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_624_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSetArrayEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_624_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvePointSetArrayEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_624_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvePointSetArrayEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_624_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSetArrayEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_624_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSetArrayEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_624_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePointSetArrayEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_624_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSetArrayEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_624_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePointSetArrayEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvePointSetArrayEditor G__TTEvePointSetArrayEditor;
static int G__G__Eve2_624_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[] (TEvePointSetArrayEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvePointSetArrayEditor*) (soff+(sizeof(TEvePointSetArrayEditor)*i)))->~G__TTEvePointSetArrayEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvePointSetArrayEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvePointSetArrayEditor*) (soff))->~G__TTEvePointSetArrayEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvePointSetProjected */
static int G__G__Eve2_625_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePointSetProjected* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePointSetProjected[n];
     } else {
       p = new((void*) gvp) TEvePointSetProjected[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePointSetProjected;
     } else {
       p = new((void*) gvp) TEvePointSetProjected;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_625_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvePointSetProjected::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_625_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSetProjected::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_625_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvePointSetProjected::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_625_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvePointSetProjected::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_625_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePointSetProjected*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_625_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSetProjected::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_625_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePointSetProjected::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_625_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePointSetProjected::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_625_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePointSetProjected::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvePointSetProjected G__TTEvePointSetProjected;
static int G__G__Eve2_625_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[] (TEvePointSetProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvePointSetProjected*) (soff+(sizeof(TEvePointSetProjected)*i)))->~G__TTEvePointSetProjected();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvePointSetProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvePointSetProjected*) (soff))->~G__TTEvePointSetProjected();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveLineProjected */
static int G__G__Eve2_626_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveLineProjected* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveLineProjected[n];
     } else {
       p = new((void*) gvp) TEveLineProjected[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveLineProjected;
     } else {
       p = new((void*) gvp) TEveLineProjected;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_626_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveLineProjected::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_626_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveLineProjected::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_626_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveLineProjected::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_626_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveLineProjected::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_626_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveLineProjected*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_626_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveLineProjected::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_626_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveLineProjected::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_626_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveLineProjected::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_626_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveLineProjected::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveLineProjected G__TTEveLineProjected;
static int G__G__Eve2_626_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[] (TEveLineProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveLineProjected*) (soff+(sizeof(TEveLineProjected)*i)))->~G__TTEveLineProjected();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveLineProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveLineProjected*) (soff))->~G__TTEveLineProjected();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvePolygonSetProjected */
static int G__G__Eve2_627_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePolygonSetProjected* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePolygonSetProjected((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEvePolygonSetProjected((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 TEvePolygonSetProjected((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEvePolygonSetProjected((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 TEvePolygonSetProjected[n];
       } else {
         p = new((void*) gvp) TEvePolygonSetProjected[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEvePolygonSetProjected;
       } else {
         p = new((void*) gvp) TEvePolygonSetProjected;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_627_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePolygonSetProjected*) G__getstructoffset())->ProjectBuffer3D();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_627_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEvePolygonSetProjected*) G__getstructoffset())->DumpPolys();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_627_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePolygonSetProjected*) G__getstructoffset())->DumpBuffer3D();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_627_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvePolygonSetProjected::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_627_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePolygonSetProjected::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_627_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvePolygonSetProjected::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_627_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvePolygonSetProjected::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_627_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePolygonSetProjected*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_627_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePolygonSetProjected::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_627_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePolygonSetProjected::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_627_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePolygonSetProjected::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_627_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePolygonSetProjected::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvePolygonSetProjected G__TTEvePolygonSetProjected;
static int G__G__Eve2_627_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[] (TEvePolygonSetProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvePolygonSetProjected*) (soff+(sizeof(TEvePolygonSetProjected)*i)))->~G__TTEvePolygonSetProjected();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvePolygonSetProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvePolygonSetProjected*) (soff))->~G__TTEvePolygonSetProjected();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvePolygonSetProjectedGL */
static int G__G__Eve2_628_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePolygonSetProjectedGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePolygonSetProjectedGL[n];
     } else {
       p = new((void*) gvp) TEvePolygonSetProjectedGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePolygonSetProjectedGL;
     } else {
       p = new((void*) gvp) TEvePolygonSetProjectedGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjectedGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_628_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvePolygonSetProjectedGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_628_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePolygonSetProjectedGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_628_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvePolygonSetProjectedGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_628_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvePolygonSetProjectedGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_628_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePolygonSetProjectedGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_628_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePolygonSetProjectedGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_628_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePolygonSetProjectedGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_628_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePolygonSetProjectedGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_628_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePolygonSetProjectedGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvePolygonSetProjectedGL G__TTEvePolygonSetProjectedGL;
static int G__G__Eve2_628_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[] (TEvePolygonSetProjectedGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvePolygonSetProjectedGL*) (soff+(sizeof(TEvePolygonSetProjectedGL)*i)))->~G__TTEvePolygonSetProjectedGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvePolygonSetProjectedGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvePolygonSetProjectedGL*) (soff))->~G__TTEvePolygonSetProjectedGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveQuadSet */
static int G__G__Eve2_639_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveQuadSet* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveQuadSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveQuadSet((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 TEveQuadSet((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveQuadSet((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 TEveQuadSet[n];
       } else {
         p = new((void*) gvp) TEveQuadSet[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveQuadSet;
       } else {
         p = new((void*) gvp) TEveQuadSet;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveQuadSet* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveQuadSet(
(TEveQuadSet::EQuadType_e) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TEveQuadSet(
(TEveQuadSet::EQuadType_e) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveQuadSet(
(TEveQuadSet::EQuadType_e) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TEveQuadSet(
(TEveQuadSet::EQuadType_e) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Int_t) 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 TEveQuadSet(
(TEveQuadSet::EQuadType_e) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveQuadSet(
(TEveQuadSet::EQuadType_e) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveQuadSet*) G__getstructoffset())->Reset((TEveQuadSet::EQuadType_e) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveQuadSet*) G__getstructoffset())->GetDefWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveQuadSet*) G__getstructoffset())->GetDefHeight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveQuadSet*) G__getstructoffset())->GetDefCoord());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveQuadSet*) G__getstructoffset())->SetDefWidth((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveQuadSet*) G__getstructoffset())->SetDefHeight((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveQuadSet*) G__getstructoffset())->SetDefCoord((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveQuadSet*) G__getstructoffset())->AddQuad((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveQuadSet*) G__getstructoffset())->AddQuad((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveQuadSet*) G__getstructoffset())->AddQuad((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__Eve2_639_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveQuadSet*) G__getstructoffset())->AddQuad((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveQuadSet*) G__getstructoffset())->AddQuad((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])
, (Float_t) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveQuadSet*) G__getstructoffset())->AddLine((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveQuadSet*) G__getstructoffset())->AddHexagon((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveQuadSet*) G__getstructoffset())->QuadValue((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveQuadSet*) G__getstructoffset())->QuadColor((Color_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TEveQuadSet*) G__getstructoffset())->QuadColor((UChar_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]), (UChar_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TEveQuadSet*) G__getstructoffset())->QuadColor((UChar_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveQuadSet*) G__getstructoffset())->QuadId((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveQuadSet::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveQuadSet::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveQuadSet::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveQuadSet::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveQuadSet*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveQuadSet::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveQuadSet::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveQuadSet::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_639_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveQuadSet::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveQuadSet G__TTEveQuadSet;
static int G__G__Eve2_639_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[] (TEveQuadSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveQuadSet*) (soff+(sizeof(TEveQuadSet)*i)))->~G__TTEveQuadSet();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveQuadSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveQuadSet*) (soff))->~G__TTEveQuadSet();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveQuadSetGL */
static int G__G__Eve2_640_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveQuadSetGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveQuadSetGL[n];
     } else {
       p = new((void*) gvp) TEveQuadSetGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveQuadSetGL;
     } else {
       p = new((void*) gvp) TEveQuadSetGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_640_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveQuadSetGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_640_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveQuadSetGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_640_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveQuadSetGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_640_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveQuadSetGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_640_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveQuadSetGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_640_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveQuadSetGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_640_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveQuadSetGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_640_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveQuadSetGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_640_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveQuadSetGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveQuadSetGL G__TTEveQuadSetGL;
static int G__G__Eve2_640_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[] (TEveQuadSetGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveQuadSetGL*) (soff+(sizeof(TEveQuadSetGL)*i)))->~G__TTEveQuadSetGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveQuadSetGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveQuadSetGL*) (soff))->~G__TTEveQuadSetGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveStraightLineSet */
static int G__G__Eve2_687_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveStraightLineSet* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveStraightLineSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveStraightLineSet((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 TEveStraightLineSet((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveStraightLineSet((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 TEveStraightLineSet[n];
       } else {
         p = new((void*) gvp) TEveStraightLineSet[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveStraightLineSet;
       } else {
         p = new((void*) gvp) TEveStraightLineSet;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveStraightLineSet*) G__getstructoffset())->AddLine((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])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveStraightLineSet*) G__getstructoffset())->AddLine(*(TEveVector*) libp->para[0].ref, *(TEveVector*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 83, (long) ((TEveStraightLineSet*) G__getstructoffset())->AddMarker((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 83, (long) ((TEveStraightLineSet*) G__getstructoffset())->AddMarker((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 83, (long) ((TEveStraightLineSet*) G__getstructoffset())->AddMarker(*(TEveVector*) libp->para[0].ref, (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 83, (long) ((TEveStraightLineSet*) G__getstructoffset())->AddMarker(*(TEveVector*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 83, (long) ((TEveStraightLineSet*) G__getstructoffset())->AddMarker((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveStraightLineSet*) G__getstructoffset())->SetLine(
(int) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
, (Float_t) G__double(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveStraightLineSet*) G__getstructoffset())->SetLine((int) G__int(libp->para[0]), *(TEveVector*) libp->para[1].ref
, *(TEveVector*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveChunkManager& obj = ((TEveStraightLineSet*) G__getstructoffset())->GetLinePlex();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveChunkManager& obj = ((TEveStraightLineSet*) G__getstructoffset())->GetMarkerPlex();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveStraightLineSet*) G__getstructoffset())->GetRnrMarkers());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveStraightLineSet*) G__getstructoffset())->GetRnrLines());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveStraightLineSet*) G__getstructoffset())->GetDepthTest());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveStraightLineSet*) G__getstructoffset())->SetRnrMarkers((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveStraightLineSet*) G__getstructoffset())->SetRnrLines((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveStraightLineSet*) G__getstructoffset())->SetDepthTest((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveStraightLineSet::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveStraightLineSet::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveStraightLineSet::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveStraightLineSet::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveStraightLineSet*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveStraightLineSet::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveStraightLineSet::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveStraightLineSet::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_687_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveStraightLineSet::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveStraightLineSet G__TTEveStraightLineSet;
static int G__G__Eve2_687_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[] (TEveStraightLineSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveStraightLineSet*) (soff+(sizeof(TEveStraightLineSet)*i)))->~G__TTEveStraightLineSet();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveStraightLineSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveStraightLineSet*) (soff))->~G__TTEveStraightLineSet();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveStraightLineSetProjected */
static int G__G__Eve2_690_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveStraightLineSetProjected* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveStraightLineSetProjected[n];
     } else {
       p = new((void*) gvp) TEveStraightLineSetProjected[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveStraightLineSetProjected;
     } else {
       p = new((void*) gvp) TEveStraightLineSetProjected;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_690_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveStraightLineSetProjected::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_690_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveStraightLineSetProjected::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_690_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveStraightLineSetProjected::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_690_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveStraightLineSetProjected::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_690_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveStraightLineSetProjected*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_690_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveStraightLineSetProjected::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_690_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveStraightLineSetProjected::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_690_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveStraightLineSetProjected::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_690_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveStraightLineSetProjected::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveStraightLineSetProjected G__TTEveStraightLineSetProjected;
static int G__G__Eve2_690_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[] (TEveStraightLineSetProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveStraightLineSetProjected*) (soff+(sizeof(TEveStraightLineSetProjected)*i)))->~G__TTEveStraightLineSetProjected();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveStraightLineSetProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveStraightLineSetProjected*) (soff))->~G__TTEveStraightLineSetProjected();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveScalableStraightLineSet */
static int G__G__Eve2_691_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveScalableStraightLineSet* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveScalableStraightLineSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveScalableStraightLineSet((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 TEveScalableStraightLineSet((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveScalableStraightLineSet((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 TEveScalableStraightLineSet[n];
       } else {
         p = new((void*) gvp) TEveScalableStraightLineSet[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveScalableStraightLineSet;
       } else {
         p = new((void*) gvp) TEveScalableStraightLineSet;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveScalableStraightLineSet));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_691_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveScalableStraightLineSet*) G__getstructoffset())->SetScaleCenter((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__Eve2_691_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveScalableStraightLineSet*) G__getstructoffset())->SetScale((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_691_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TEveScalableStraightLineSet*) G__getstructoffset())->GetScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_691_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveScalableStraightLineSet::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_691_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveScalableStraightLineSet::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_691_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveScalableStraightLineSet::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_691_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveScalableStraightLineSet::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_691_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveScalableStraightLineSet*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_691_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveScalableStraightLineSet::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_691_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveScalableStraightLineSet::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_691_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveScalableStraightLineSet::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_691_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveScalableStraightLineSet::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveScalableStraightLineSet G__TTEveScalableStraightLineSet;
static int G__G__Eve2_691_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[] (TEveScalableStraightLineSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveScalableStraightLineSet*) (soff+(sizeof(TEveScalableStraightLineSet)*i)))->~G__TTEveScalableStraightLineSet();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveScalableStraightLineSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveScalableStraightLineSet*) (soff))->~G__TTEveScalableStraightLineSet();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveStraightLineSetEditor */
static int G__G__Eve2_692_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveStraightLineSetEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveStraightLineSetEditor(
(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) TEveStraightLineSetEditor(
(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 TEveStraightLineSetEditor(
(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) TEveStraightLineSetEditor(
(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 TEveStraightLineSetEditor(
(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) TEveStraightLineSetEditor(
(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 TEveStraightLineSetEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveStraightLineSetEditor((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 TEveStraightLineSetEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveStraightLineSetEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveStraightLineSetEditor[n];
       } else {
         p = new((void*) gvp) TEveStraightLineSetEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveStraightLineSetEditor;
       } else {
         p = new((void*) gvp) TEveStraightLineSetEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_692_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveStraightLineSetEditor*) G__getstructoffset())->DoRnrMarkers();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_692_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveStraightLineSetEditor*) G__getstructoffset())->DoRnrLines();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_692_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveStraightLineSetEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_692_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveStraightLineSetEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_692_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveStraightLineSetEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_692_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveStraightLineSetEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_692_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveStraightLineSetEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_692_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveStraightLineSetEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_692_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveStraightLineSetEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_692_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveStraightLineSetEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_692_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveStraightLineSetEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveStraightLineSetEditor G__TTEveStraightLineSetEditor;
static int G__G__Eve2_692_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[] (TEveStraightLineSetEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveStraightLineSetEditor*) (soff+(sizeof(TEveStraightLineSetEditor)*i)))->~G__TTEveStraightLineSetEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveStraightLineSetEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveStraightLineSetEditor*) (soff))->~G__TTEveStraightLineSetEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveStraightLineSetGL */
static int G__G__Eve2_693_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveStraightLineSetGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveStraightLineSetGL[n];
     } else {
       p = new((void*) gvp) TEveStraightLineSetGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveStraightLineSetGL;
     } else {
       p = new((void*) gvp) TEveStraightLineSetGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_693_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveStraightLineSetGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_693_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveStraightLineSetGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_693_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveStraightLineSetGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_693_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveStraightLineSetGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_693_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveStraightLineSetGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_693_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveStraightLineSetGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_693_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveStraightLineSetGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_693_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveStraightLineSetGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_693_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveStraightLineSetGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveStraightLineSetGL G__TTEveStraightLineSetGL;
static int G__G__Eve2_693_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[] (TEveStraightLineSetGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveStraightLineSetGL*) (soff+(sizeof(TEveStraightLineSetGL)*i)))->~G__TTEveStraightLineSetGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveStraightLineSetGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveStraightLineSetGL*) (soff))->~G__TTEveStraightLineSetGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveText */
static int G__G__Eve2_695_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveText* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveText((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveText((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 TEveText[n];
       } else {
         p = new((void*) gvp) TEveText[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveText;
       } else {
         p = new((void*) gvp) TEveText;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveText));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveText*) G__getstructoffset())->GetFontSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveText*) G__getstructoffset())->GetFontFile());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveText*) G__getstructoffset())->GetFontMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEveText*) G__getstructoffset())->SetFontSize((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveText*) G__getstructoffset())->SetFontSize((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveText*) G__getstructoffset())->SetFontFile((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveText*) G__getstructoffset())->SetFontFile((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveText*) G__getstructoffset())->SetFontMode((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TEveText*) G__getstructoffset())->GetText());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveText*) G__getstructoffset())->SetText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveText*) G__getstructoffset())->GetLighting());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveText*) G__getstructoffset())->SetLighting((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveText*) G__getstructoffset())->GetAutoLighting());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveText*) G__getstructoffset())->SetAutoLighting((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveText*) G__getstructoffset())->GetExtrude());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveText*) G__getstructoffset())->SetExtrude((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveText*) G__getstructoffset())->GetPolygonOffset((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveText*) G__getstructoffset())->SetPolygonOffset((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveText::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveText::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveText::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveText::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveText*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveText::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveText::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveText::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_695_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveText::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveText G__TTEveText;
static int G__G__Eve2_695_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveText*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveText*) (soff+(sizeof(TEveText)*i)))->~G__TTEveText();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveText*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveText*) (soff))->~G__TTEveText();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTextEditor */
static int G__G__Eve2_696_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTextEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTextEditor(
(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) TEveTextEditor(
(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 TEveTextEditor(
(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) TEveTextEditor(
(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 TEveTextEditor(
(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) TEveTextEditor(
(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 TEveTextEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveTextEditor((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 TEveTextEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveTextEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveTextEditor[n];
       } else {
         p = new((void*) gvp) TEveTextEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveTextEditor;
       } else {
         p = new((void*) gvp) TEveTextEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveTextEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_696_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTextEditor*) G__getstructoffset())->DoText((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_696_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTextEditor*) G__getstructoffset())->DoFontSize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_696_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTextEditor*) G__getstructoffset())->DoFontFile();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_696_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTextEditor*) G__getstructoffset())->DoFontMode();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_696_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTextEditor*) G__getstructoffset())->DoLighting();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_696_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTextEditor*) G__getstructoffset())->DoAutoLighting();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_696_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTextEditor*) G__getstructoffset())->DoExtrude();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_696_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTextEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_696_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTextEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_696_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTextEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_696_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTextEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_696_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTextEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_696_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTextEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_696_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTextEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_696_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTextEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_696_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTextEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTextEditor G__TTEveTextEditor;
static int G__G__Eve2_696_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[] (TEveTextEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTextEditor*) (soff+(sizeof(TEveTextEditor)*i)))->~G__TTEveTextEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTextEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTextEditor*) (soff))->~G__TTEveTextEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTextGL */
static int G__G__Eve2_697_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTextGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTextGL[n];
     } else {
       p = new((void*) gvp) TEveTextGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTextGL;
     } else {
       p = new((void*) gvp) TEveTextGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveTextGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_697_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTextGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_697_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTextGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_697_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTextGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_697_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTextGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_697_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTextGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_697_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTextGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_697_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTextGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_697_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTextGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_697_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTextGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTextGL G__TTEveTextGL;
static int G__G__Eve2_697_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[] (TEveTextGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTextGL*) (soff+(sizeof(TEveTextGL)*i)))->~G__TTEveTextGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTextGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTextGL*) (soff))->~G__TTEveTextGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTrackPropagatorSubEditor */
static int G__G__Eve2_698_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrackPropagatorSubEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveTrackPropagatorSubEditor((TGWindow*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TEveTrackPropagatorSubEditor((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__Eve2LN_TEveTrackPropagatorSubEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagatorSubEditor*) G__getstructoffset())->SetModel((TEveTrackPropagator*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagatorSubEditor*) G__getstructoffset())->Changed();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagatorSubEditor*) G__getstructoffset())->DoMaxR();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagatorSubEditor*) G__getstructoffset())->DoMaxZ();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagatorSubEditor*) G__getstructoffset())->DoMaxOrbits();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagatorSubEditor*) G__getstructoffset())->DoMaxAng();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagatorSubEditor*) G__getstructoffset())->DoDelta();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagatorSubEditor*) G__getstructoffset())->DoFitPM();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagatorSubEditor*) G__getstructoffset())->DoRnrPM();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagatorSubEditor*) G__getstructoffset())->DoRnrFV();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagatorSubEditor*) G__getstructoffset())->DoModePTB((UChar_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagatorSubEditor*) G__getstructoffset())->DoRnrPTB();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagatorSubEditor*) G__getstructoffset())->CreateRefsContainer((TGVerticalFrame*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTrackPropagatorSubEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackPropagatorSubEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTrackPropagatorSubEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTrackPropagatorSubEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagatorSubEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackPropagatorSubEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackPropagatorSubEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackPropagatorSubEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_698_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackPropagatorSubEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTrackPropagatorSubEditor G__TTEveTrackPropagatorSubEditor;
static int G__G__Eve2_698_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[] (TEveTrackPropagatorSubEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTrackPropagatorSubEditor*) (soff+(sizeof(TEveTrackPropagatorSubEditor)*i)))->~G__TTEveTrackPropagatorSubEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTrackPropagatorSubEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTrackPropagatorSubEditor*) (soff))->~G__TTEveTrackPropagatorSubEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTrack */
static int G__G__Eve2_699_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrack* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrack[n];
     } else {
       p = new((void*) gvp) TEveTrack[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrack;
     } else {
       p = new((void*) gvp) TEveTrack;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrack* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrack(
(TParticle*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TEveTrackPropagator*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveTrack(
(TParticle*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TEveTrackPropagator*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrack((TParticle*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveTrack((TParticle*) G__int(libp->para[0]), (Int_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__Eve2LN_TEveTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrack* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrack((TEveMCTrack*) G__int(libp->para[0]), (TEveTrackPropagator*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveTrack((TEveMCTrack*) G__int(libp->para[0]), (TEveTrackPropagator*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrack((TEveMCTrack*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveTrack((TEveMCTrack*) 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__Eve2LN_TEveTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrack* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrack((TEveRecTrack*) G__int(libp->para[0]), (TEveTrackPropagator*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveTrack((TEveRecTrack*) G__int(libp->para[0]), (TEveTrackPropagator*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrack((TEveRecTrack*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveTrack((TEveRecTrack*) 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__Eve2LN_TEveTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrack* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveTrack(*(TEveTrack*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TEveTrack(*(TEveTrack*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrack*) G__getstructoffset())->SetStdTitle();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrack*) G__getstructoffset())->SetTrackParams(*(TEveTrack*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrack*) G__getstructoffset())->SetPathMarks(*(TEveTrack*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveTrack*) G__getstructoffset())->MakeTrack((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveTrack*) G__getstructoffset())->MakeTrack();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveTrack*) G__getstructoffset())->GetPropagator());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveTrack*) G__getstructoffset())->GetLastPMIdx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrack*) G__getstructoffset())->SetPropagator((TEveTrackPropagator*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrack*) G__getstructoffset())->SetAttLineAttMarker((TEveTrackList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector& obj = ((const TEveTrack*) G__getstructoffset())->GetVertex();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector& obj = ((const TEveTrack*) G__getstructoffset())->GetMomentum();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector& obj = ((const TEveTrack*) G__getstructoffset())->GetEndMomentum();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveTrack*) G__getstructoffset())->GetPdg());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrack*) G__getstructoffset())->SetPdg((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveTrack*) G__getstructoffset())->GetCharge());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrack*) G__getstructoffset())->SetCharge((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveTrack*) G__getstructoffset())->GetLabel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrack*) G__getstructoffset())->SetLabel((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveTrack*) G__getstructoffset())->GetIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrack*) G__getstructoffset())->SetIndex((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveTrack*) G__getstructoffset())->GetStatus());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrack*) G__getstructoffset())->SetStatus((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrack*) G__getstructoffset())->AddPathMark(*(TEvePathMark*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrack*) G__getstructoffset())->SortPathMarksByTime();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveTrack::vPathMark_t& obj = ((TEveTrack*) G__getstructoffset())->RefPathMarks();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveTrack::vPathMark_t& obj = ((const TEveTrack*) G__getstructoffset())->RefPathMarks();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrack*) G__getstructoffset())->PrintPathMarks();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrack*) G__getstructoffset())->SetLockPoints((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrack*) G__getstructoffset())->GetLockPoints());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrack*) G__getstructoffset())->SecSelected((TEveTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrack*) G__getstructoffset())->ShouldBreakTrack());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 98, (long) ((const TEveTrack*) G__getstructoffset())->GetBreakProjectedTracks());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrack*) G__getstructoffset())->SetBreakProjectedTracks((UChar_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TEveTrack::GetDefaultBreakProjectedTracks());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTrack::SetDefaultBreakProjectedTracks((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTrack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTrack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTrack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_699_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTrack G__TTEveTrack;
static int G__G__Eve2_699_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTrack*) (soff+(sizeof(TEveTrack)*i)))->~G__TTEveTrack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTrack*) (soff))->~G__TTEveTrack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTrackList */
static int G__G__Eve2_700_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrackList* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrackList((TEveTrackPropagator*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveTrackList((TEveTrackPropagator*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveTrackList[n];
       } else {
         p = new((void*) gvp) TEveTrackList[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveTrackList;
       } else {
         p = new((void*) gvp) TEveTrackList;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrackList* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrackList((const char*) G__int(libp->para[0]), (TEveTrackPropagator*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveTrackList((const char*) G__int(libp->para[0]), (TEveTrackPropagator*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrackList((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveTrackList((const char*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveTrackList*) G__getstructoffset())->MakeTracks((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveTrackList*) G__getstructoffset())->MakeTracks();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TEveTrackList*) G__getstructoffset())->FindMomentumLimits((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveTrackList*) G__getstructoffset())->FindMomentumLimits();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackList*) G__getstructoffset())->SetPropagator((TEveTrackPropagator*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveTrackList*) G__getstructoffset())->GetPropagator());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrackList*) G__getstructoffset())->GetRecurse());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackList*) G__getstructoffset())->SetRecurse((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackList*) G__getstructoffset())->SetLineColor((Color_t) G__int(libp->para[0]), (TEveElement*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackList*) G__getstructoffset())->SetLineWidth((Width_t) G__int(libp->para[0]), (TEveElement*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackList*) G__getstructoffset())->SetLineStyle((Style_t) G__int(libp->para[0]), (TEveElement*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackList*) G__getstructoffset())->SetMarkerColor((Color_t) G__int(libp->para[0]), (TEveElement*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackList*) G__getstructoffset())->SetMarkerSize((Size_t) G__double(libp->para[0]), (TEveElement*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackList*) G__getstructoffset())->SetMarkerStyle((Style_t) G__int(libp->para[0]), (TEveElement*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackList*) G__getstructoffset())->SetRnrLine((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackList*) G__getstructoffset())->SetRnrLine((Bool_t) G__int(libp->para[0]), (TEveElement*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrackList*) G__getstructoffset())->GetRnrLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackList*) G__getstructoffset())->SetRnrPoints((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackList*) G__getstructoffset())->SetRnrPoints((Bool_t) G__int(libp->para[0]), (TEveElement*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrackList*) G__getstructoffset())->GetRnrPoints());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackList*) G__getstructoffset())->SelectByPt((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackList*) G__getstructoffset())->SelectByPt((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (TEveElement*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackList*) G__getstructoffset())->SelectByP((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackList*) G__getstructoffset())->SelectByP((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (TEveElement*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveTrackList*) G__getstructoffset())->GetMinPt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveTrackList*) G__getstructoffset())->GetMaxPt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveTrackList*) G__getstructoffset())->GetLimPt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveTrackList*) G__getstructoffset())->GetMinP());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveTrackList*) G__getstructoffset())->GetMaxP());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveTrackList*) G__getstructoffset())->GetLimP());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveTrackList*) G__getstructoffset())->FindTrackByLabel((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TEveTrackList*) G__getstructoffset())->FindTrackByIndex((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTrackList::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackList::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTrackList::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTrackList::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackList*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackList::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackList::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackList::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_700_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackList::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTrackList G__TTEveTrackList;
static int G__G__Eve2_700_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveTrackList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTrackList*) (soff+(sizeof(TEveTrackList)*i)))->~G__TTEveTrackList();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTrackList*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTrackList*) (soff))->~G__TTEveTrackList();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTrackEditor */
static int G__G__Eve2_701_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrackEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrackEditor(
(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) TEveTrackEditor(
(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 TEveTrackEditor(
(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) TEveTrackEditor(
(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 TEveTrackEditor(
(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) TEveTrackEditor(
(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 TEveTrackEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveTrackEditor((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 TEveTrackEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveTrackEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveTrackEditor[n];
       } else {
         p = new((void*) gvp) TEveTrackEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveTrackEditor;
       } else {
         p = new((void*) gvp) TEveTrackEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_701_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackEditor*) G__getstructoffset())->DoEditPropagator();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_701_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTrackEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_701_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_701_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTrackEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_701_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTrackEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_701_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_701_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_701_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_701_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_701_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTrackEditor G__TTEveTrackEditor;
static int G__G__Eve2_701_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[] (TEveTrackEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTrackEditor*) (soff+(sizeof(TEveTrackEditor)*i)))->~G__TTEveTrackEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTrackEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTrackEditor*) (soff))->~G__TTEveTrackEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTrackListEditor */
static int G__G__Eve2_702_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrackListEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrackListEditor(
(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) TEveTrackListEditor(
(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 TEveTrackListEditor(
(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) TEveTrackListEditor(
(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 TEveTrackListEditor(
(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) TEveTrackListEditor(
(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 TEveTrackListEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveTrackListEditor((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 TEveTrackListEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveTrackListEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveTrackListEditor[n];
       } else {
         p = new((void*) gvp) TEveTrackListEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveTrackListEditor;
       } else {
         p = new((void*) gvp) TEveTrackListEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_702_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackListEditor*) G__getstructoffset())->CreateRefsTab();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_702_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackListEditor*) G__getstructoffset())->DoRnrLine();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_702_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackListEditor*) G__getstructoffset())->DoRnrPoints();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_702_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackListEditor*) G__getstructoffset())->DoPtRange();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_702_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackListEditor*) G__getstructoffset())->DoPRange();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_702_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTrackListEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_702_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackListEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_702_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTrackListEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_702_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTrackListEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_702_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackListEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_702_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackListEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_702_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackListEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_702_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackListEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_702_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackListEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTrackListEditor G__TTEveTrackListEditor;
static int G__G__Eve2_702_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[] (TEveTrackListEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTrackListEditor*) (soff+(sizeof(TEveTrackListEditor)*i)))->~G__TTEveTrackListEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTrackListEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTrackListEditor*) (soff))->~G__TTEveTrackListEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTrackGL */
static int G__G__Eve2_703_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrackGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrackGL[n];
     } else {
       p = new((void*) gvp) TEveTrackGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrackGL;
     } else {
       p = new((void*) gvp) TEveTrackGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_703_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTrackGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_703_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_703_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTrackGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_703_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTrackGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_703_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_703_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_703_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_703_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_703_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTrackGL G__TTEveTrackGL;
static int G__G__Eve2_703_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[] (TEveTrackGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTrackGL*) (soff+(sizeof(TEveTrackGL)*i)))->~G__TTEveTrackGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTrackGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTrackGL*) (soff))->~G__TTEveTrackGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTrackPropagator */
static int G__G__Eve2_710_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrackPropagator* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrackPropagator(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TEveMagField*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TEveTrackPropagator(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TEveMagField*) 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 TEveTrackPropagator(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TEveMagField*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveTrackPropagator(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TEveMagField*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrackPropagator((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveTrackPropagator((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 TEveTrackPropagator((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveTrackPropagator((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 TEveTrackPropagator[n];
       } else {
         p = new((void*) gvp) TEveTrackPropagator[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveTrackPropagator;
       } else {
         p = new((void*) gvp) TEveTrackPropagator;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->InitTrack(*(TEveVector*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->ResetTrack();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->GoToBounds(*(TEveVector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveTrackPropagator*) G__getstructoffset())->GoToVertex(*(TEveVector*) libp->para[0].ref, *(TEveVector*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TEveTrackPropagator*) G__getstructoffset())->IntersectPlane(*(TEveVector*) libp->para[0].ref, *(TEveVector*) libp->para[1].ref
, *(TEveVector*) libp->para[2].ref, *(TEveVector*) libp->para[3].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveTrackPropagator*) G__getstructoffset())->FillPointSet((TEvePointSet*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetStepper((TEveTrackPropagator::EStepper_e) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetMagField((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__Eve2_710_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetMagField((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TEveTrackPropagator*) G__getstructoffset())->SetMagFieldObj((TEveMagField*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveTrackPropagator*) G__getstructoffset())->SetMagFieldObj((TEveMagField*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetMaxR((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetMaxZ((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetMaxOrbs((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetMinAng((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetMaxAng((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetMaxStep((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetDelta((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetEditPathMarks((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetRnrDaughters((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetRnrReferences((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetRnrDecay((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetRnrCluster2Ds((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetFitDaughters((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetFitReferences((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetFitDecay((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetFitCluster2Ds((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetRnrFV((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetProjTrackBreaking((UChar_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->SetRnrPTBMarkers((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TEveVector* pobj;
         TEveVector xobj = ((TEveTrackPropagator*) G__getstructoffset())->GetMagField((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
         pobj = new TEveVector(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__Eve2_710_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveTrackPropagator*) G__getstructoffset())->PrintMagField((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__Eve2_710_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveTrackPropagator*) G__getstructoffset())->GetStepper());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveTrackPropagator*) G__getstructoffset())->GetMaxR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveTrackPropagator*) G__getstructoffset())->GetMaxZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveTrackPropagator*) G__getstructoffset())->GetMaxOrbs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveTrackPropagator*) G__getstructoffset())->GetMinAng());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveTrackPropagator*) G__getstructoffset())->GetMaxAng());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveTrackPropagator*) G__getstructoffset())->GetMaxStep());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveTrackPropagator*) G__getstructoffset())->GetDelta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrackPropagator*) G__getstructoffset())->GetEditPathMarks());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrackPropagator*) G__getstructoffset())->GetRnrDaughters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrackPropagator*) G__getstructoffset())->GetRnrReferences());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrackPropagator*) G__getstructoffset())->GetRnrDecay());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrackPropagator*) G__getstructoffset())->GetRnrCluster2Ds());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrackPropagator*) G__getstructoffset())->GetFitDaughters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrackPropagator*) G__getstructoffset())->GetFitReferences());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrackPropagator*) G__getstructoffset())->GetFitDecay());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrackPropagator*) G__getstructoffset())->GetFitCluster2Ds());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrackPropagator*) G__getstructoffset())->GetRnrFV());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 98, (long) ((const TEveTrackPropagator*) G__getstructoffset())->GetProjTrackBreaking());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveTrackPropagator*) G__getstructoffset())->GetRnrPTBMarkers());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMarker& obj = ((TEveTrackPropagator*) G__getstructoffset())->RefPMAtt();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMarker& obj = ((TEveTrackPropagator*) G__getstructoffset())->RefFVAtt();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMarker& obj = ((TEveTrackPropagator*) G__getstructoffset())->RefPTBAtt();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TEveTrackPropagator::IsOutsideBounds(*(TEveVector*) libp->para[0].ref, (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTrackPropagator::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackPropagator::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTrackPropagator::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTrackPropagator::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagator*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackPropagator::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackPropagator::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackPropagator::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_710_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackPropagator::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTrackPropagator G__TTEveTrackPropagator;
static int G__G__Eve2_710_0_85(G__value* result7, G__CONST 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[] (TEveTrackPropagator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTrackPropagator*) (soff+(sizeof(TEveTrackPropagator)*i)))->~G__TTEveTrackPropagator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTrackPropagator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTrackPropagator*) (soff))->~G__TTEveTrackPropagator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTrackProjected */
static int G__G__Eve2_719_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrackProjected* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrackProjected[n];
     } else {
       p = new((void*) gvp) TEveTrackProjected[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrackProjected;
     } else {
       p = new((void*) gvp) TEveTrackProjected;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_719_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackProjected*) G__getstructoffset())->PrintLineSegments();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_719_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTrackProjected::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_719_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackProjected::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_719_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTrackProjected::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_719_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTrackProjected::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_719_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackProjected*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_719_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackProjected::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_719_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackProjected::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_719_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackProjected::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_719_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackProjected::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTrackProjected G__TTEveTrackProjected;
static int G__G__Eve2_719_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[] (TEveTrackProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTrackProjected*) (soff+(sizeof(TEveTrackProjected)*i)))->~G__TTEveTrackProjected();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTrackProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTrackProjected*) (soff))->~G__TTEveTrackProjected();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTrackProjectedGL */
static int G__G__Eve2_720_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrackProjectedGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrackProjectedGL[n];
     } else {
       p = new((void*) gvp) TEveTrackProjectedGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrackProjectedGL;
     } else {
       p = new((void*) gvp) TEveTrackProjectedGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjectedGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_720_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTrackProjectedGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_720_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackProjectedGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_720_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTrackProjectedGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_720_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTrackProjectedGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_720_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackProjectedGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_720_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackProjectedGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_720_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackProjectedGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_720_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackProjectedGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_720_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackProjectedGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTrackProjectedGL G__TTEveTrackProjectedGL;
static int G__G__Eve2_720_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[] (TEveTrackProjectedGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTrackProjectedGL*) (soff+(sizeof(TEveTrackProjectedGL)*i)))->~G__TTEveTrackProjectedGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTrackProjectedGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTrackProjectedGL*) (soff))->~G__TTEveTrackProjectedGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTrackListProjected */
static int G__G__Eve2_721_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrackListProjected* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrackListProjected[n];
     } else {
       p = new((void*) gvp) TEveTrackListProjected[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrackListProjected;
     } else {
       p = new((void*) gvp) TEveTrackListProjected;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListProjected));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_721_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackListProjected*) G__getstructoffset())->SetDepth((Float_t) G__double(libp->para[0]), (TEveElement*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_721_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTrackListProjected::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_721_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackListProjected::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_721_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTrackListProjected::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_721_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTrackListProjected::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_721_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackListProjected*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_721_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackListProjected::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_721_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackListProjected::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_721_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackListProjected::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_721_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackListProjected::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTrackListProjected G__TTEveTrackListProjected;
static int G__G__Eve2_721_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[] (TEveTrackListProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTrackListProjected*) (soff+(sizeof(TEveTrackListProjected)*i)))->~G__TTEveTrackListProjected();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTrackListProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTrackListProjected*) (soff))->~G__TTEveTrackListProjected();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTrackPropagatorEditor */
static int G__G__Eve2_725_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTrackPropagatorEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTrackPropagatorEditor(
(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) TEveTrackPropagatorEditor(
(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 TEveTrackPropagatorEditor(
(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) TEveTrackPropagatorEditor(
(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 TEveTrackPropagatorEditor(
(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) TEveTrackPropagatorEditor(
(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 TEveTrackPropagatorEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveTrackPropagatorEditor((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 TEveTrackPropagatorEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveTrackPropagatorEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveTrackPropagatorEditor[n];
       } else {
         p = new((void*) gvp) TEveTrackPropagatorEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveTrackPropagatorEditor;
       } else {
         p = new((void*) gvp) TEveTrackPropagatorEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_725_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTrackPropagatorEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_725_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackPropagatorEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_725_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTrackPropagatorEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_725_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTrackPropagatorEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_725_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTrackPropagatorEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_725_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackPropagatorEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_725_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackPropagatorEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_725_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTrackPropagatorEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_725_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTrackPropagatorEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTrackPropagatorEditor G__TTEveTrackPropagatorEditor;
static int G__G__Eve2_725_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[] (TEveTrackPropagatorEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTrackPropagatorEditor*) (soff+(sizeof(TEveTrackPropagatorEditor)*i)))->~G__TTEveTrackPropagatorEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTrackPropagatorEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTrackPropagatorEditor*) (soff))->~G__TTEveTrackPropagatorEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveMagField */
static int G__G__Eve2_726_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEveMagField*) G__getstructoffset())->IsConst());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_726_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TEveMagField*) G__getstructoffset())->PrintField((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__Eve2_726_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector* pobj;
         const TEveVector xobj = ((const TEveMagField*) G__getstructoffset())->GetField(*(TEveVector*) libp->para[0].ref);
         pobj = new TEveVector(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__Eve2_726_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TEveVector* pobj;
         const TEveVector xobj = ((const TEveMagField*) G__getstructoffset())->GetField((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
         pobj = new TEveVector(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__Eve2_726_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TEveMagField*) G__getstructoffset())->GetMaxFieldMag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_726_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveMagField::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_726_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMagField::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_726_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveMagField::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_726_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveMagField::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_726_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEveMagField*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_726_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveMagField*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_726_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveMagField*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_726_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveMagField*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_726_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMagField::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_726_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveMagField::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_726_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMagField::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_726_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveMagField::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveMagField G__TTEveMagField;
static int G__G__Eve2_726_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[] (TEveMagField*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveMagField*) (soff+(sizeof(TEveMagField)*i)))->~G__TTEveMagField();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveMagField*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveMagField*) (soff))->~G__TTEveMagField();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve2_726_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveMagField* dest = (TEveMagField*) G__getstructoffset();
   *dest = *(TEveMagField*) libp->para[0].ref;
   const TEveMagField& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveMagFieldConst */
static int G__G__Eve2_727_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveMagFieldConst* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveMagFieldConst(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) TEveMagFieldConst(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldConst));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_727_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveMagFieldConst::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_727_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMagFieldConst::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_727_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveMagFieldConst::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_727_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveMagFieldConst::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_727_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveMagFieldConst*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_727_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMagFieldConst::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_727_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveMagFieldConst::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_727_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMagFieldConst::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_727_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveMagFieldConst::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve2_727_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveMagFieldConst* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveMagFieldConst(*(TEveMagFieldConst*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldConst));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveMagFieldConst G__TTEveMagFieldConst;
static int G__G__Eve2_727_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[] (TEveMagFieldConst*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveMagFieldConst*) (soff+(sizeof(TEveMagFieldConst)*i)))->~G__TTEveMagFieldConst();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveMagFieldConst*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveMagFieldConst*) (soff))->~G__TTEveMagFieldConst();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve2_727_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveMagFieldConst* dest = (TEveMagFieldConst*) G__getstructoffset();
   *dest = *(TEveMagFieldConst*) libp->para[0].ref;
   const TEveMagFieldConst& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveMagFieldDuo */
static int G__G__Eve2_728_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveMagFieldDuo* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TEveMagFieldDuo(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) TEveMagFieldDuo(
(Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldDuo));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_728_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveMagFieldDuo::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_728_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMagFieldDuo::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_728_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveMagFieldDuo::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_728_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveMagFieldDuo::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_728_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveMagFieldDuo*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_728_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMagFieldDuo::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_728_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveMagFieldDuo::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_728_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveMagFieldDuo::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_728_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveMagFieldDuo::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Eve2_728_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TEveMagFieldDuo* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TEveMagFieldDuo(*(TEveMagFieldDuo*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldDuo));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveMagFieldDuo G__TTEveMagFieldDuo;
static int G__G__Eve2_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveMagFieldDuo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveMagFieldDuo*) (soff+(sizeof(TEveMagFieldDuo)*i)))->~G__TTEveMagFieldDuo();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveMagFieldDuo*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveMagFieldDuo*) (soff))->~G__TTEveMagFieldDuo();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Eve2_728_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveMagFieldDuo* dest = (TEveMagFieldDuo*) G__getstructoffset();
   *dest = *(TEveMagFieldDuo*) libp->para[0].ref;
   const TEveMagFieldDuo& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTriangleSet */
static int G__G__Eve2_736_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTriangleSet* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTriangleSet(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TEveTriangleSet(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTriangleSet(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TEveTriangleSet(
(Int_t) G__int(libp->para[0]), (Int_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 TEveTriangleSet((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveTriangleSet((Int_t) G__int(libp->para[0]), (Int_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__Eve2LN_TEveTriangleSet));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveTriangleSet*) G__getstructoffset())->GetNVerts());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveTriangleSet*) G__getstructoffset())->GetNTrings());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((TEveTriangleSet*) G__getstructoffset())->Vertex((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((TEveTriangleSet*) G__getstructoffset())->Triangle((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((TEveTriangleSet*) G__getstructoffset())->TriangleNormal((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 66, (long) ((TEveTriangleSet*) G__getstructoffset())->TriangleColor((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTriangleSet*) G__getstructoffset())->SetVertex((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTriangleSet*) G__getstructoffset())->SetTriangle((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TEveTriangleSet*) G__getstructoffset())->SetTriangleColor((Int_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]), (UChar_t) G__int(libp->para[3])
, (UChar_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TEveTriangleSet*) G__getstructoffset())->SetTriangleColor((Int_t) G__int(libp->para[0]), (UChar_t) G__int(libp->para[1])
, (UChar_t) G__int(libp->para[2]), (UChar_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTriangleSet*) G__getstructoffset())->GenerateTriangleNormals();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTriangleSet*) G__getstructoffset())->GenerateRandomColors();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TEveTriangleSet*) G__getstructoffset())->GenerateZNormalColors((Float_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TEveTriangleSet*) G__getstructoffset())->GenerateZNormalColors((Float_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TEveTriangleSet*) G__getstructoffset())->GenerateZNormalColors((Float_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TEveTriangleSet*) G__getstructoffset())->GenerateZNormalColors((Float_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TEveTriangleSet*) G__getstructoffset())->GenerateZNormalColors((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TEveTriangleSet*) G__getstructoffset())->GenerateZNormalColors();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTriangleSet*) G__getstructoffset())->SetTransparency((Char_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTriangleSet::ReadTrivialFile((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTriangleSet::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTriangleSet::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTriangleSet::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTriangleSet::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTriangleSet*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTriangleSet::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTriangleSet::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTriangleSet::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_736_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTriangleSet::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTriangleSet G__TTEveTriangleSet;
static int G__G__Eve2_736_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[] (TEveTriangleSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTriangleSet*) (soff+(sizeof(TEveTriangleSet)*i)))->~G__TTEveTriangleSet();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTriangleSet*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTriangleSet*) (soff))->~G__TTEveTriangleSet();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTriangleSetEditor */
static int G__G__Eve2_737_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTriangleSetEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTriangleSetEditor(
(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) TEveTriangleSetEditor(
(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 TEveTriangleSetEditor(
(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) TEveTriangleSetEditor(
(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 TEveTriangleSetEditor(
(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) TEveTriangleSetEditor(
(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 TEveTriangleSetEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveTriangleSetEditor((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 TEveTriangleSetEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveTriangleSetEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveTriangleSetEditor[n];
       } else {
         p = new((void*) gvp) TEveTriangleSetEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveTriangleSetEditor;
       } else {
         p = new((void*) gvp) TEveTriangleSetEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_737_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTriangleSetEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_737_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTriangleSetEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_737_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTriangleSetEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_737_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTriangleSetEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_737_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTriangleSetEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_737_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTriangleSetEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_737_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTriangleSetEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_737_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTriangleSetEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_737_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTriangleSetEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTriangleSetEditor G__TTEveTriangleSetEditor;
static int G__G__Eve2_737_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[] (TEveTriangleSetEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTriangleSetEditor*) (soff+(sizeof(TEveTriangleSetEditor)*i)))->~G__TTEveTriangleSetEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTriangleSetEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTriangleSetEditor*) (soff))->~G__TTEveTriangleSetEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveTriangleSetGL */
static int G__G__Eve2_738_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveTriangleSetGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTriangleSetGL[n];
     } else {
       p = new((void*) gvp) TEveTriangleSetGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveTriangleSetGL;
     } else {
       p = new((void*) gvp) TEveTriangleSetGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_738_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveTriangleSetGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_738_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTriangleSetGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_738_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveTriangleSetGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_738_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveTriangleSetGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_738_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveTriangleSetGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_738_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTriangleSetGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_738_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTriangleSetGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_738_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveTriangleSetGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_738_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveTriangleSetGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveTriangleSetGL G__TTEveTriangleSetGL;
static int G__G__Eve2_738_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveTriangleSetGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveTriangleSetGL*) (soff+(sizeof(TEveTriangleSetGL)*i)))->~G__TTEveTriangleSetGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveTriangleSetGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveTriangleSetGL*) (soff))->~G__TTEveTriangleSetGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveJetCone */
static int G__G__Eve2_739_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveJetCone* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveJetCone((const Text_t*) G__int(libp->para[0]), (const Text_t*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveJetCone((const Text_t*) G__int(libp->para[0]), (const Text_t*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveJetCone((const Text_t*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveJetCone((const Text_t*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveJetCone[n];
       } else {
         p = new((void*) gvp) TEveJetCone[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveJetCone;
       } else {
         p = new((void*) gvp) TEveJetCone;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveJetCone));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_739_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveJetCone*) G__getstructoffset())->SetApex(*(TEveVector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_739_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveJetCone*) G__getstructoffset())->SetCylinder((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_739_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveJetCone*) G__getstructoffset())->SetRadius((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_739_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TEveJetCone*) G__getstructoffset())->GetNDiv());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_739_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveJetCone*) G__getstructoffset())->SetNDiv((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_739_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 105, (long) ((TEveJetCone*) G__getstructoffset())->AddCone((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 105, (long) ((TEveJetCone*) G__getstructoffset())->AddCone((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_739_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 105, (long) ((TEveJetCone*) G__getstructoffset())->AddEllipticCone((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])
, (Float_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 105, (long) ((TEveJetCone*) G__getstructoffset())->AddEllipticCone((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_739_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveJetCone::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_739_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveJetCone::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_739_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveJetCone::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_739_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveJetCone::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_739_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveJetCone*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_739_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveJetCone::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_739_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveJetCone::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_739_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveJetCone::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_739_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveJetCone::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveJetCone G__TTEveJetCone;
static int G__G__Eve2_739_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[] (TEveJetCone*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveJetCone*) (soff+(sizeof(TEveJetCone)*i)))->~G__TTEveJetCone();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveJetCone*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveJetCone*) (soff))->~G__TTEveJetCone();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveJetConeEditor */
static int G__G__Eve2_740_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveJetConeEditor* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveJetConeEditor(
(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) TEveJetConeEditor(
(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 TEveJetConeEditor(
(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) TEveJetConeEditor(
(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 TEveJetConeEditor(
(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) TEveJetConeEditor(
(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 TEveJetConeEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveJetConeEditor((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 TEveJetConeEditor((TGWindow*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveJetConeEditor((TGWindow*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveJetConeEditor[n];
       } else {
         p = new((void*) gvp) TEveJetConeEditor[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveJetConeEditor;
       } else {
         p = new((void*) gvp) TEveJetConeEditor;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeEditor));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_740_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveJetConeEditor::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_740_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveJetConeEditor::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_740_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveJetConeEditor::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_740_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveJetConeEditor::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_740_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveJetConeEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_740_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveJetConeEditor::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_740_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveJetConeEditor::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_740_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveJetConeEditor::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_740_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveJetConeEditor::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveJetConeEditor G__TTEveJetConeEditor;
static int G__G__Eve2_740_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[] (TEveJetConeEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveJetConeEditor*) (soff+(sizeof(TEveJetConeEditor)*i)))->~G__TTEveJetConeEditor();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveJetConeEditor*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveJetConeEditor*) (soff))->~G__TTEveJetConeEditor();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveJetConeProjected */
static int G__G__Eve2_741_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveJetConeProjected* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveJetConeProjected((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEveJetConeProjected((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 TEveJetConeProjected((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEveJetConeProjected((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 TEveJetConeProjected[n];
       } else {
         p = new((void*) gvp) TEveJetConeProjected[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEveJetConeProjected;
       } else {
         p = new((void*) gvp) TEveJetConeProjected;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjected));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_741_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveJetConeProjected::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_741_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveJetConeProjected::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_741_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveJetConeProjected::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_741_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveJetConeProjected::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_741_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveJetConeProjected*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_741_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveJetConeProjected::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_741_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveJetConeProjected::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_741_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveJetConeProjected::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_741_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveJetConeProjected::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveJetConeProjected G__TTEveJetConeProjected;
static int G__G__Eve2_741_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[] (TEveJetConeProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveJetConeProjected*) (soff+(sizeof(TEveJetConeProjected)*i)))->~G__TTEveJetConeProjected();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveJetConeProjected*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveJetConeProjected*) (soff))->~G__TTEveJetConeProjected();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveJetConeGL */
static int G__G__Eve2_742_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveJetConeGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveJetConeGL[n];
     } else {
       p = new((void*) gvp) TEveJetConeGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveJetConeGL;
     } else {
       p = new((void*) gvp) TEveJetConeGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_742_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveJetConeGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_742_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveJetConeGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_742_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveJetConeGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_742_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveJetConeGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_742_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveJetConeGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_742_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveJetConeGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_742_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveJetConeGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_742_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveJetConeGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_742_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveJetConeGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveJetConeGL G__TTEveJetConeGL;
static int G__G__Eve2_742_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[] (TEveJetConeGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveJetConeGL*) (soff+(sizeof(TEveJetConeGL)*i)))->~G__TTEveJetConeGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveJetConeGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveJetConeGL*) (soff))->~G__TTEveJetConeGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEveJetConeProjectedGL */
static int G__G__Eve2_747_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEveJetConeProjectedGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveJetConeProjectedGL[n];
     } else {
       p = new((void*) gvp) TEveJetConeProjectedGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEveJetConeProjectedGL;
     } else {
       p = new((void*) gvp) TEveJetConeProjectedGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjectedGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_747_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEveJetConeProjectedGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_747_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveJetConeProjectedGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_747_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEveJetConeProjectedGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_747_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEveJetConeProjectedGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_747_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEveJetConeProjectedGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_747_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveJetConeProjectedGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_747_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveJetConeProjectedGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_747_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEveJetConeProjectedGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_747_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEveJetConeProjectedGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEveJetConeProjectedGL G__TTEveJetConeProjectedGL;
static int G__G__Eve2_747_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEveJetConeProjectedGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEveJetConeProjectedGL*) (soff+(sizeof(TEveJetConeProjectedGL)*i)))->~G__TTEveJetConeProjectedGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEveJetConeProjectedGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEveJetConeProjectedGL*) (soff))->~G__TTEveJetConeProjectedGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvePlot3D */
static int G__G__Eve2_748_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePlot3D* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePlot3D((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TEvePlot3D((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 TEvePlot3D((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TEvePlot3D((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 TEvePlot3D[n];
       } else {
         p = new((void*) gvp) TEvePlot3D[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TEvePlot3D;
       } else {
         p = new((void*) gvp) TEvePlot3D;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3D));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePlot3D*) G__getstructoffset())->SetPlot((TObject*) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TEvePlot3D*) G__getstructoffset())->GetPlot());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TEvePlot3D*) G__getstructoffset())->GetPlotOption();
         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__Eve2_748_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePlot3D*) G__getstructoffset())->SetLogXYZ((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePlot3D*) G__getstructoffset())->SetLogX((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePlot3D*) G__getstructoffset())->SetLogY((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePlot3D*) G__getstructoffset())->SetLogZ((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEvePlot3D*) G__getstructoffset())->GetLogX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEvePlot3D*) G__getstructoffset())->GetLogY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TEvePlot3D*) G__getstructoffset())->GetLogZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvePlot3D::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePlot3D::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvePlot3D::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvePlot3D::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePlot3D*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePlot3D::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePlot3D::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePlot3D::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_748_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePlot3D::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvePlot3D G__TTEvePlot3D;
static int G__G__Eve2_748_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[] (TEvePlot3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvePlot3D*) (soff+(sizeof(TEvePlot3D)*i)))->~G__TTEvePlot3D();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvePlot3D*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvePlot3D*) (soff))->~G__TTEvePlot3D();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TEvePlot3DGL */
static int G__G__Eve2_750_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TEvePlot3DGL* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePlot3DGL[n];
     } else {
       p = new((void*) gvp) TEvePlot3DGL[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TEvePlot3DGL;
     } else {
       p = new((void*) gvp) TEvePlot3DGL;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3DGL));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_750_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TEvePlot3DGL::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_750_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePlot3DGL::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_750_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TEvePlot3DGL::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_750_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TEvePlot3DGL::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_750_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TEvePlot3DGL*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_750_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePlot3DGL::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_750_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePlot3DGL::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_750_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TEvePlot3DGL::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Eve2_750_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TEvePlot3DGL::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TEvePlot3DGL G__TTEvePlot3DGL;
static int G__G__Eve2_750_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TEvePlot3DGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TEvePlot3DGL*) (soff+(sizeof(TEvePlot3DGL)*i)))->~G__TTEvePlot3DGL();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TEvePlot3DGL*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TEvePlot3DGL*) (soff))->~G__TTEvePlot3DGL();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* TEveArrow */

/* TEveArrowEditor */

/* TEveArrowGL */

/* TEveBox */

/* TEveBoxProjected */

/* TEveBoxGL */

/* TEveBoxProjectedGL */

/* TEveShape */

/* TEveShapeEditor */

/* TEveFrameBox */

/* TEveFrameBoxGL */

/* TEveRGBAPalette */

/* TEveRGBAPaletteEditor */

/* TEveRGBAPaletteSubEditor */

/* TEveDigitSet */

/* TEveDigitSetEditor */

/* TEveDigitSetGL */

/* TEveBoxSet */

/* TEveBoxSetGL */

/* TEveCaloData */

/* TEveCaloData::SliceInfo_t */

/* TEveCaloDataVec */

/* TEveCaloDataHist */

/* TEveCaloViz */

/* TEveCaloVizEditor */

/* TEveCalo3D */

/* TEveCalo3DGL */

/* TEveCalo2D */

/* TEveCalo2DGL */

/* TEveCaloLego */

/* TEveCaloLegoGL */

/* TEveCaloLegoOverlay */

/* TEveCaloLegoEditor */

/* TEveCalo3DEditor */

/* TEveGeoNode */

/* TEveGeoTopNode */

/* TEveGeoNodeEditor */

/* TEveGeoTopNodeEditor */

/* TEveGeoShapeExtract */

/* TEveGeoShape */

/* TEveGeoShapeProjected */

/* TEveGeoPolyShape */

/* TEveGridStepper */

/* TEveGridStepperSubEditor */

/* TEveGridStepperEditor */

/* TEveLegoEventHandler */

/* TEveLine */

/* TEveLineEditor */

/* TEveLineGL */

/* TEvePointSet */

/* TEvePointSetArray */

/* TEvePointSetArrayEditor */

/* TEvePointSetProjected */

/* TEveLineProjected */

/* TEvePolygonSetProjected */

/* TEvePolygonSetProjectedGL */

/* TEveQuadSet */

/* TEveQuadSetGL */

/* TEveStraightLineSet */

/* TEveStraightLineSetProjected */

/* TEveScalableStraightLineSet */

/* TEveStraightLineSetEditor */

/* TEveStraightLineSetGL */

/* TEveText */

/* TEveTextEditor */

/* TEveTextGL */

/* TEveTrackPropagatorSubEditor */

/* TEveTrack */

/* TEveTrackList */

/* TEveTrackEditor */

/* TEveTrackListEditor */

/* TEveTrackGL */

/* TEveTrackPropagator */

/* TEveTrackProjected */

/* TEveTrackProjectedGL */

/* TEveTrackListProjected */

/* TEveTrackPropagatorEditor */

/* TEveMagField */

/* TEveMagFieldConst */

/* TEveMagFieldDuo */

/* TEveTriangleSet */

/* TEveTriangleSetEditor */

/* TEveTriangleSetGL */

/* TEveJetCone */

/* TEveJetConeEditor */

/* TEveJetConeProjected */

/* TEveJetConeGL */

/* TEveJetConeProjectedGL */

/* TEvePlot3D */

/* TEvePlot3DGL */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__Eve2 {
 public:
  G__Sizep2memfuncG__Eve2(): p(&G__Sizep2memfuncG__Eve2::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__Eve2::*p)();
};

size_t G__get_sizep2memfuncG__Eve2()
{
  G__Sizep2memfuncG__Eve2 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__Eve2() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrow))) {
     TEveArrow *G__Lderived;
     G__Lderived=(TEveArrow*)0x1000;
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrow),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrow),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrow),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrow),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrow),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowEditor))) {
     TEveArrowEditor *G__Lderived;
     G__Lderived=(TEveArrowEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowGL))) {
     TEveArrowGL *G__Lderived;
     G__Lderived=(TEveArrowGL*)0x1000;
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveBox))) {
     TEveBox *G__Lderived;
     G__Lderived=(TEveBox*)0x1000;
     {
       TEveShape *G__Lpbase=(TEveShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBox),G__get_linked_tagnum(&G__G__Eve2LN_TEveShape),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBox),G__get_linked_tagnum(&G__G__Eve2LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBox),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBox),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBox),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBox),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBox),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBox),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjected))) {
     TEveBoxProjected *G__Lderived;
     G__Lderived=(TEveBoxProjected*)0x1000;
     {
       TEveShape *G__Lpbase=(TEveShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveShape),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjected),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjected),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjected *G__Lpbase=(TEveProjected*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjected),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxGL))) {
     TEveBoxGL *G__Lderived;
     G__Lderived=(TEveBoxGL*)0x1000;
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjectedGL))) {
     TEveBoxProjectedGL *G__Lderived;
     G__Lderived=(TEveBoxProjectedGL*)0x1000;
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjectedGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjectedGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveShape))) {
     TEveShape *G__Lderived;
     G__Lderived=(TEveShape*)0x1000;
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShape),G__get_linked_tagnum(&G__G__Eve2LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShape),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShape),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShape),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShape),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShape),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShape),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveShapeEditor))) {
     TEveShapeEditor *G__Lderived;
     G__Lderived=(TEveShapeEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShapeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShapeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShapeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShapeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShapeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShapeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShapeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBox))) {
     TEveFrameBox *G__Lderived;
     G__Lderived=(TEveFrameBox*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBox),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveRefBackPtr *G__Lpbase=(TEveRefBackPtr*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBox),G__get_linked_tagnum(&G__G__Eve2LN_TEveRefBackPtr),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveRefCnt *G__Lpbase=(TEveRefCnt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBox),G__get_linked_tagnum(&G__G__Eve2LN_TEveRefCnt),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette))) {
     TEveRGBAPalette *G__Lderived;
     G__Lderived=(TEveRGBAPalette*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveRefCnt *G__Lpbase=(TEveRefCnt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette),G__get_linked_tagnum(&G__G__Eve2LN_TEveRefCnt),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteEditor))) {
     TEveRGBAPaletteEditor *G__Lderived;
     G__Lderived=(TEveRGBAPaletteEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteSubEditor))) {
     TEveRGBAPaletteSubEditor *G__Lderived;
     G__Lderived=(TEveRGBAPaletteSubEditor*)0x1000;
     {
       TGVerticalFrame *G__Lpbase=(TGVerticalFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGVerticalFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSet))) {
     TEveDigitSet *G__Lderived;
     G__Lderived=(TEveDigitSet*)0x1000;
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSet),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSet),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSet),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSet),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSet),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveSecondarySelectable *G__Lpbase=(TEveSecondarySelectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveSecondarySelectable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetEditor))) {
     TEveDigitSetEditor *G__Lderived;
     G__Lderived=(TEveDigitSetEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetGL))) {
     TEveDigitSetGL *G__Lderived;
     G__Lderived=(TEveDigitSetGL*)0x1000;
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSet))) {
     TEveBoxSet *G__Lderived;
     G__Lderived=(TEveBoxSet*)0x1000;
     {
       TEveDigitSet *G__Lpbase=(TEveDigitSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSet),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSet),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSet),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSet),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSet),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSet),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveSecondarySelectable *G__Lpbase=(TEveSecondarySelectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveSecondarySelectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSetGL))) {
     TEveBoxSetGL *G__Lderived;
     G__Lderived=(TEveBoxSetGL*)0x1000;
     {
       TEveDigitSetGL *G__Lpbase=(TEveDigitSetGL*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSetGL),G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetGL),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSetGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSetGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData))) {
     TEveCaloData *G__Lderived;
     G__Lderived=(TEveCaloData*)0x1000;
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataVec))) {
     TEveCaloDataVec *G__Lderived;
     G__Lderived=(TEveCaloDataVec*)0x1000;
     {
       TEveCaloData *G__Lpbase=(TEveCaloData*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataVec),G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataVec),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataVec),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataVec),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataHist))) {
     TEveCaloDataHist *G__Lderived;
     G__Lderived=(TEveCaloDataHist*)0x1000;
     {
       TEveCaloData *G__Lpbase=(TEveCaloData*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataHist),G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataHist),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataHist),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataHist),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloViz))) {
     TEveCaloViz *G__Lderived;
     G__Lderived=(TEveCaloViz*)0x1000;
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloViz),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloViz),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloViz),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloViz),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloViz),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloViz),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloVizEditor))) {
     TEveCaloVizEditor *G__Lderived;
     G__Lderived=(TEveCaloVizEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloVizEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloVizEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloVizEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloVizEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloVizEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloVizEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloVizEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3D))) {
     TEveCalo3D *G__Lderived;
     G__Lderived=(TEveCalo3D*)0x1000;
     {
       TEveCaloViz *G__Lpbase=(TEveCaloViz*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3D),G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloViz),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3D),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3D),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3D),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3D),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3D),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3D),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DGL))) {
     TEveCalo3DGL *G__Lderived;
     G__Lderived=(TEveCalo3DGL*)0x1000;
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D))) {
     TEveCalo2D *G__Lderived;
     G__Lderived=(TEveCalo2D*)0x1000;
     {
       TEveCaloViz *G__Lpbase=(TEveCaloViz*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D),G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloViz),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjected *G__Lpbase=(TEveProjected*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjected),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2DGL))) {
     TEveCalo2DGL *G__Lderived;
     G__Lderived=(TEveCalo2DGL*)0x1000;
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2DGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2DGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego))) {
     TEveCaloLego *G__Lderived;
     G__Lderived=(TEveCaloLego*)0x1000;
     {
       TEveCaloViz *G__Lpbase=(TEveCaloViz*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego),G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloViz),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoGL))) {
     TEveCaloLegoGL *G__Lderived;
     G__Lderived=(TEveCaloLegoGL*)0x1000;
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoOverlay))) {
     TEveCaloLegoOverlay *G__Lderived;
     G__Lderived=(TEveCaloLegoOverlay*)0x1000;
     {
       TGLCameraOverlay *G__Lpbase=(TGLCameraOverlay*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoOverlay),G__get_linked_tagnum(&G__G__Eve2LN_TGLCameraOverlay),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLOverlayElement *G__Lpbase=(TGLOverlayElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoOverlay),G__get_linked_tagnum(&G__G__Eve2LN_TGLOverlayElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoEditor))) {
     TEveCaloLegoEditor *G__Lderived;
     G__Lderived=(TEveCaloLegoEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TGLCameraOverlay))) {
     TGLCameraOverlay *G__Lderived;
     G__Lderived=(TGLCameraOverlay*)0x1000;
     {
       TGLOverlayElement *G__Lpbase=(TGLOverlayElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TGLCameraOverlay),G__get_linked_tagnum(&G__G__Eve2LN_TGLOverlayElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DEditor))) {
     TEveCalo3DEditor *G__Lderived;
     G__Lderived=(TEveCalo3DEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNode))) {
     TEveGeoNode *G__Lderived;
     G__Lderived=(TEveGeoNode*)0x1000;
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNode),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNode),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNode))) {
     TEveGeoTopNode *G__Lderived;
     G__Lderived=(TEveGeoTopNode*)0x1000;
     {
       TEveGeoNode *G__Lpbase=(TEveGeoNode*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNode),G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNode),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNode),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNode),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNodeEditor))) {
     TEveGeoNodeEditor *G__Lderived;
     G__Lderived=(TEveGeoNodeEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNodeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNodeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNodeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNodeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNodeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNodeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNodeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNodeEditor))) {
     TEveGeoTopNodeEditor *G__Lderived;
     G__Lderived=(TEveGeoTopNodeEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNodeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNodeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNodeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNodeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNodeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNodeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNodeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeExtract))) {
     TEveGeoShapeExtract *G__Lderived;
     G__Lderived=(TEveGeoShapeExtract*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeExtract),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeExtract),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShape))) {
     TEveGeoShape *G__Lderived;
     G__Lderived=(TEveGeoShape*)0x1000;
     {
       TEveShape *G__Lpbase=(TEveShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShape),G__get_linked_tagnum(&G__G__Eve2LN_TEveShape),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShape),G__get_linked_tagnum(&G__G__Eve2LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShape),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShape),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShape),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShape),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShape),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShape),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeProjected))) {
     TEveGeoShapeProjected *G__Lderived;
     G__Lderived=(TEveGeoShapeProjected*)0x1000;
     {
       TEveShape *G__Lpbase=(TEveShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveShape),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjected *G__Lpbase=(TEveProjected*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjected),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoPolyShape))) {
     TEveGeoPolyShape *G__Lderived;
     G__Lderived=(TEveGeoPolyShape*)0x1000;
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoPolyShape),G__get_linked_tagnum(&G__G__Eve2LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoPolyShape),G__get_linked_tagnum(&G__G__Eve2LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoPolyShape),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoPolyShape),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepper))) {
     TEveGridStepper *G__Lderived;
     G__Lderived=(TEveGridStepper*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepper),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperSubEditor))) {
     TEveGridStepperSubEditor *G__Lderived;
     G__Lderived=(TEveGridStepperSubEditor*)0x1000;
     {
       TGVerticalFrame *G__Lpbase=(TGVerticalFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGVerticalFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperEditor))) {
     TEveGridStepperEditor *G__Lderived;
     G__Lderived=(TEveGridStepperEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveLegoEventHandler))) {
     TEveLegoEventHandler *G__Lderived;
     G__Lderived=(TEveLegoEventHandler*)0x1000;
     {
       TGLEventHandler *G__Lpbase=(TGLEventHandler*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLegoEventHandler),G__get_linked_tagnum(&G__G__Eve2LN_TGLEventHandler),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGEventHandler *G__Lpbase=(TGEventHandler*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLegoEventHandler),G__get_linked_tagnum(&G__G__Eve2LN_TGEventHandler),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLegoEventHandler),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLegoEventHandler),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLegoEventHandler),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveLine))) {
     TEveLine *G__Lderived;
     G__Lderived=(TEveLine*)0x1000;
     {
       TEvePointSet *G__Lpbase=(TEvePointSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLine),G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLine),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TPointSet3D *G__Lpbase=(TPointSet3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLine),G__get_linked_tagnum(&G__G__Eve2LN_TPointSet3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TPolyMarker3D *G__Lpbase=(TPolyMarker3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLine),G__get_linked_tagnum(&G__G__Eve2LN_TPolyMarker3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLine),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLine),G__get_linked_tagnum(&G__G__Eve2LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLine),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLine),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEvePointSelectorConsumer *G__Lpbase=(TEvePointSelectorConsumer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLine),G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSelectorConsumer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLine),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLine),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLine),G__get_linked_tagnum(&G__G__Eve2LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineEditor))) {
     TEveLineEditor *G__Lderived;
     G__Lderived=(TEveLineEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineGL))) {
     TEveLineGL *G__Lderived;
     G__Lderived=(TEveLineGL*)0x1000;
     {
       TPointSet3DGL *G__Lpbase=(TPointSet3DGL*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineGL),G__get_linked_tagnum(&G__G__Eve2LN_TPointSet3DGL),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TPolyMarker3D))) {
     TPolyMarker3D *G__Lderived;
     G__Lderived=(TPolyMarker3D*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TPolyMarker3D),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TPolyMarker3D),G__get_linked_tagnum(&G__G__Eve2LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TPolyMarker3D),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TPointSet3D))) {
     TPointSet3D *G__Lderived;
     G__Lderived=(TPointSet3D*)0x1000;
     {
       TPolyMarker3D *G__Lpbase=(TPolyMarker3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TPointSet3D),G__get_linked_tagnum(&G__G__Eve2LN_TPolyMarker3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TPointSet3D),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TPointSet3D),G__get_linked_tagnum(&G__G__Eve2LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TPointSet3D),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TPointSet3D),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet))) {
     TEvePointSet *G__Lderived;
     G__Lderived=(TEvePointSet*)0x1000;
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TPointSet3D *G__Lpbase=(TPointSet3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet),G__get_linked_tagnum(&G__G__Eve2LN_TPointSet3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TPolyMarker3D *G__Lpbase=(TPolyMarker3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet),G__get_linked_tagnum(&G__G__Eve2LN_TPolyMarker3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet),G__get_linked_tagnum(&G__G__Eve2LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEvePointSelectorConsumer *G__Lpbase=(TEvePointSelectorConsumer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet),G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSelectorConsumer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArray))) {
     TEvePointSetArray *G__Lderived;
     G__Lderived=(TEvePointSetArray*)0x1000;
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArray),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArray),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArray),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArray),G__get_linked_tagnum(&G__G__Eve2LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEvePointSelectorConsumer *G__Lpbase=(TEvePointSelectorConsumer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArray),G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSelectorConsumer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArrayEditor))) {
     TEvePointSetArrayEditor *G__Lderived;
     G__Lderived=(TEvePointSetArrayEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArrayEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArrayEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArrayEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArrayEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArrayEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArrayEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArrayEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected))) {
     TEvePointSetProjected *G__Lderived;
     G__Lderived=(TEvePointSetProjected*)0x1000;
     {
       TEvePointSet *G__Lpbase=(TEvePointSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TPointSet3D *G__Lpbase=(TPointSet3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TPointSet3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TPolyMarker3D *G__Lpbase=(TPolyMarker3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TPolyMarker3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEvePointSelectorConsumer *G__Lpbase=(TEvePointSelectorConsumer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSelectorConsumer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjected *G__Lpbase=(TEveProjected*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjected),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected))) {
     TEveLineProjected *G__Lderived;
     G__Lderived=(TEveLineProjected*)0x1000;
     {
       TEveLine *G__Lpbase=(TEveLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEvePointSet *G__Lpbase=(TEvePointSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TPointSet3D *G__Lpbase=(TPointSet3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected),G__get_linked_tagnum(&G__G__Eve2LN_TPointSet3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TPolyMarker3D *G__Lpbase=(TPolyMarker3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected),G__get_linked_tagnum(&G__G__Eve2LN_TPolyMarker3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEvePointSelectorConsumer *G__Lpbase=(TEvePointSelectorConsumer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSelectorConsumer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjected *G__Lpbase=(TEveProjected*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjected),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected))) {
     TEvePolygonSetProjected *G__Lderived;
     G__Lderived=(TEvePolygonSetProjected*)0x1000;
     {
       TEveShape *G__Lpbase=(TEveShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveShape),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjected *G__Lpbase=(TEveProjected*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjected),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjectedGL))) {
     TEvePolygonSetProjectedGL *G__Lderived;
     G__Lderived=(TEvePolygonSetProjectedGL*)0x1000;
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjectedGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjectedGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet))) {
     TEveQuadSet *G__Lderived;
     G__Lderived=(TEveQuadSet*)0x1000;
     {
       TEveDigitSet *G__Lpbase=(TEveDigitSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSet),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveSecondarySelectable *G__Lpbase=(TEveSecondarySelectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveSecondarySelectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetGL))) {
     TEveQuadSetGL *G__Lderived;
     G__Lderived=(TEveQuadSetGL*)0x1000;
     {
       TEveDigitSetGL *G__Lpbase=(TEveDigitSetGL*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetGL),G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetGL),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet))) {
     TEveStraightLineSet *G__Lderived;
     G__Lderived=(TEveStraightLineSet*)0x1000;
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected))) {
     TEveStraightLineSetProjected *G__Lderived;
     G__Lderived=(TEveStraightLineSetProjected*)0x1000;
     {
       TEveStraightLineSet *G__Lpbase=(TEveStraightLineSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjected *G__Lpbase=(TEveProjected*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjected),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveScalableStraightLineSet))) {
     TEveScalableStraightLineSet *G__Lderived;
     G__Lderived=(TEveScalableStraightLineSet*)0x1000;
     {
       TEveStraightLineSet *G__Lpbase=(TEveStraightLineSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveScalableStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveScalableStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveScalableStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveScalableStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveScalableStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveScalableStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveScalableStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveScalableStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveScalableStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveScalableStraightLineSet),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetEditor))) {
     TEveStraightLineSetEditor *G__Lderived;
     G__Lderived=(TEveStraightLineSetEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetGL))) {
     TEveStraightLineSetGL *G__Lderived;
     G__Lderived=(TEveStraightLineSetGL*)0x1000;
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveText))) {
     TEveText *G__Lderived;
     G__Lderived=(TEveText*)0x1000;
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveText),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveText),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveText),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveText),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveText),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveTextEditor))) {
     TEveTextEditor *G__Lderived;
     G__Lderived=(TEveTextEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTextEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTextEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTextEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTextEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTextEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTextEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTextEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveTextGL))) {
     TEveTextGL *G__Lderived;
     G__Lderived=(TEveTextGL*)0x1000;
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTextGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTextGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorSubEditor))) {
     TEveTrackPropagatorSubEditor *G__Lderived;
     G__Lderived=(TEveTrackPropagatorSubEditor*)0x1000;
     {
       TGVerticalFrame *G__Lpbase=(TGVerticalFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGVerticalFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorSubEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack))) {
     TEveTrack *G__Lderived;
     G__Lderived=(TEveTrack*)0x1000;
     {
       TEveLine *G__Lpbase=(TEveLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack),G__get_linked_tagnum(&G__G__Eve2LN_TEveLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEvePointSet *G__Lpbase=(TEvePointSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack),G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TPointSet3D *G__Lpbase=(TPointSet3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack),G__get_linked_tagnum(&G__G__Eve2LN_TPointSet3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TPolyMarker3D *G__Lpbase=(TPolyMarker3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack),G__get_linked_tagnum(&G__G__Eve2LN_TPolyMarker3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack),G__get_linked_tagnum(&G__G__Eve2LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEvePointSelectorConsumer *G__Lpbase=(TEvePointSelectorConsumer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack),G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSelectorConsumer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack),G__get_linked_tagnum(&G__G__Eve2LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList))) {
     TEveTrackList *G__Lderived;
     G__Lderived=(TEveTrackList*)0x1000;
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList),G__get_linked_tagnum(&G__G__Eve2LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList),G__get_linked_tagnum(&G__G__Eve2LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList),G__get_linked_tagnum(&G__G__Eve2LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackEditor))) {
     TEveTrackEditor *G__Lderived;
     G__Lderived=(TEveTrackEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListEditor))) {
     TEveTrackListEditor *G__Lderived;
     G__Lderived=(TEveTrackListEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackGL))) {
     TEveTrackGL *G__Lderived;
     G__Lderived=(TEveTrackGL*)0x1000;
     {
       TEveLineGL *G__Lpbase=(TEveLineGL*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackGL),G__get_linked_tagnum(&G__G__Eve2LN_TEveLineGL),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TPointSet3DGL *G__Lpbase=(TPointSet3DGL*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackGL),G__get_linked_tagnum(&G__G__Eve2LN_TPointSet3DGL),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator))) {
     TEveTrackPropagator *G__Lderived;
     G__Lderived=(TEveTrackPropagator*)0x1000;
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator),G__get_linked_tagnum(&G__G__Eve2LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveRefBackPtr *G__Lpbase=(TEveRefBackPtr*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator),G__get_linked_tagnum(&G__G__Eve2LN_TEveRefBackPtr),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveRefCnt *G__Lpbase=(TEveRefCnt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator),G__get_linked_tagnum(&G__G__Eve2LN_TEveRefCnt),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected))) {
     TEveTrackProjected *G__Lderived;
     G__Lderived=(TEveTrackProjected*)0x1000;
     {
       TEveTrack *G__Lpbase=(TEveTrack*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveLine *G__Lpbase=(TEveLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEvePointSet *G__Lpbase=(TEvePointSet*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TPointSet3D *G__Lpbase=(TPointSet3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected),G__get_linked_tagnum(&G__G__Eve2LN_TPointSet3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TPolyMarker3D *G__Lpbase=(TPolyMarker3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected),G__get_linked_tagnum(&G__G__Eve2LN_TPolyMarker3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEvePointSelectorConsumer *G__Lpbase=(TEvePointSelectorConsumer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSelectorConsumer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjected *G__Lpbase=(TEveProjected*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjected),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjectedGL))) {
     TEveTrackProjectedGL *G__Lderived;
     G__Lderived=(TEveTrackProjectedGL*)0x1000;
     {
       TEveTrackGL *G__Lpbase=(TEveTrackGL*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjectedGL),G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackGL),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveLineGL *G__Lpbase=(TEveLineGL*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjectedGL),G__get_linked_tagnum(&G__G__Eve2LN_TEveLineGL),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TPointSet3DGL *G__Lpbase=(TPointSet3DGL*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjectedGL),G__get_linked_tagnum(&G__G__Eve2LN_TPointSet3DGL),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjectedGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjectedGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListProjected))) {
     TEveTrackListProjected *G__Lderived;
     G__Lderived=(TEveTrackListProjected*)0x1000;
     {
       TEveTrackList *G__Lpbase=(TEveTrackList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListProjected),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListProjected),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjected *G__Lpbase=(TEveProjected*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjected),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorEditor))) {
     TEveTrackPropagatorEditor *G__Lderived;
     G__Lderived=(TEveTrackPropagatorEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldConst))) {
     TEveMagFieldConst *G__Lderived;
     G__Lderived=(TEveMagFieldConst*)0x1000;
     {
       TEveMagField *G__Lpbase=(TEveMagField*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldConst),G__get_linked_tagnum(&G__G__Eve2LN_TEveMagField),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldDuo))) {
     TEveMagFieldDuo *G__Lderived;
     G__Lderived=(TEveMagFieldDuo*)0x1000;
     {
       TEveMagField *G__Lpbase=(TEveMagField*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldDuo),G__get_linked_tagnum(&G__G__Eve2LN_TEveMagField),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSet))) {
     TEveTriangleSet *G__Lderived;
     G__Lderived=(TEveTriangleSet*)0x1000;
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSet),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSet),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSet),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSet),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSet),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetEditor))) {
     TEveTriangleSetEditor *G__Lderived;
     G__Lderived=(TEveTriangleSetEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetGL))) {
     TEveTriangleSetGL *G__Lderived;
     G__Lderived=(TEveTriangleSetGL*)0x1000;
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetCone))) {
     TEveJetCone *G__Lderived;
     G__Lderived=(TEveJetCone*)0x1000;
     {
       TEveShape *G__Lpbase=(TEveShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetCone),G__get_linked_tagnum(&G__G__Eve2LN_TEveShape),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetCone),G__get_linked_tagnum(&G__G__Eve2LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetCone),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetCone),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetCone),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetCone),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetCone),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetCone),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeEditor))) {
     TEveJetConeEditor *G__Lderived;
     G__Lderived=(TEveJetConeEditor*)0x1000;
     {
       TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGObject *G__Lpbase=(TGObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TQObject *G__Lpbase=(TQObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeEditor),G__get_linked_tagnum(&G__G__Eve2LN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjected))) {
     TEveJetConeProjected *G__Lderived;
     G__Lderived=(TEveJetConeProjected*)0x1000;
     {
       TEveShape *G__Lpbase=(TEveShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveShape),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttBBox *G__Lpbase=(TAttBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TAttBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjected *G__Lpbase=(TEveProjected*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjected),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjected),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeGL))) {
     TEveJetConeGL *G__Lderived;
     G__Lderived=(TEveJetConeGL*)0x1000;
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjectedGL))) {
     TEveJetConeProjectedGL *G__Lderived;
     G__Lderived=(TEveJetConeProjectedGL*)0x1000;
     {
       TEveJetConeGL *G__Lpbase=(TEveJetConeGL*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjectedGL),G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeGL),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjectedGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjectedGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3D))) {
     TEvePlot3D *G__Lderived;
     G__Lderived=(TEvePlot3D*)0x1000;
     {
       TEveElementList *G__Lpbase=(TEveElementList*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3D),G__get_linked_tagnum(&G__G__Eve2LN_TEveElementList),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TEveElement *G__Lpbase=(TEveElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3D),G__get_linked_tagnum(&G__G__Eve2LN_TEveElement),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3D),G__get_linked_tagnum(&G__G__Eve2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3D),G__get_linked_tagnum(&G__G__Eve2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TEveProjectable *G__Lpbase=(TEveProjectable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3D),G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3DGL))) {
     TEvePlot3DGL *G__Lderived;
     G__Lderived=(TEvePlot3DGL*)0x1000;
     {
       TGLObject *G__Lpbase=(TGLObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3DGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGLLogicalShape *G__Lpbase=(TGLLogicalShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3DGL),G__get_linked_tagnum(&G__G__Eve2LN_TGLLogicalShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__Eve2() {

   /* 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("Int_t",105,-1,0,-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("UInt_t",104,-1,0,-1);
   G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
   G__search_typename2("Long_t",108,-1,0,-1);
   G__setnewtype(-1,"Signed long integer 4 bytes (long)",0);
   G__search_typename2("Float_t",102,-1,0,-1);
   G__setnewtype(-1,"Float 4 bytes (float)",0);
   G__search_typename2("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Text_t",99,-1,0,-1);
   G__setnewtype(-1,"General string (char)",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("Style_t",115,-1,0,-1);
   G__setnewtype(-1,"Style number (short)",0);
   G__search_typename2("Marker_t",115,-1,0,-1);
   G__setnewtype(-1,"Marker number (short)",0);
   G__search_typename2("Width_t",115,-1,0,-1);
   G__setnewtype(-1,"Line width (short)",0);
   G__search_typename2("Color_t",115,-1,0,-1);
   G__setnewtype(-1,"Color number (short)",0);
   G__search_typename2("Size_t",102,-1,0,-1);
   G__setnewtype(-1,"Attribute size (float)",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Pixel_t",107,-1,0,-1);
   G__setnewtype(-1,"Pixel value",0);
   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__Eve2LN_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__Eve2LN_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__Eve2LN_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__Eve2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TGLPlane>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETGLPlanecOallocatorlETGLPlanegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETGLPlanecOallocatorlETGLPlanegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Bool_t,TGLLine3>",117,G__get_linked_tagnum(&G__G__Eve2LN_pairlEboolcOTGLLine3gR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Bool_t,TGLVertex3>",117,G__get_linked_tagnum(&G__G__Eve2LN_pairlEboolcOTGLVertex3gR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UChar_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned char>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Int_t,Int_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_pairlEintcOintgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Double_t,Double_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_pairlEdoublecOdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<double>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TEveElement*,Int_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TEveElement*,int>",117,G__get_linked_tagnum(&G__G__Eve2LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TEveElement*,int,less<TEveElement*> >",117,G__get_linked_tagnum(&G__G__Eve2LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<TEveProjected*>",117,G__get_linked_tagnum(&G__G__Eve2LN_listlETEveProjectedmUcOallocatorlETEveProjectedmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<TEveElement*>",117,G__get_linked_tagnum(&G__G__Eve2LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<TEveElement*,less<TEveElement*> >",117,G__get_linked_tagnum(&G__G__Eve2LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<TEveListTreeInfo>",117,G__get_linked_tagnum(&G__G__Eve2LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<TEveElement::TEveListTreeInfo>",117,G__get_linked_tagnum(&G__G__Eve2LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<TEveElement::TEveListTreeInfo,less<TEveElement::TEveListTreeInfo> >",117,G__get_linked_tagnum(&G__G__Eve2LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<TEveElement*>",117,G__get_linked_tagnum(&G__G__Eve2LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVectorT<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVector",117,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVectorT<Double_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVector4T<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TEveVector4TlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVector4T<Double_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TEveVector4TlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVector2T<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TEveVector2TlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEveVector2T<Double_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TEveVector2TlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEveVector2>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEveVector2T<float> >",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vVector2_t",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveShape));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vVector2_i",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveShape));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TArrayC*>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETArrayCmUcOallocatorlETArrayCmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETArrayCmUcOallocatorlETArrayCmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETArrayCmUcOallocatorlETArrayCmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETArrayCmUcOallocatorlETArrayCmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETArrayCmUcOallocatorlETArrayCmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<Int_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<int>",117,G__get_linked_tagnum(&G__G__Eve2LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("set<int,less<int> >",117,G__get_linked_tagnum(&G__G__Eve2LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Callback_foo",89,-1,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSet));
   G__setnewtype(-1,"void (*Callback_foo)(TEveDigitSet*, Int_t, TObject*);",0);
   G__search_typename2("TooltipCB_foo",89,-1,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSet));
   G__setnewtype(-1,"TString (*TooltipCB_foo)(TEveDigitSet*, Int_t);",0);
   G__search_typename2("vector<SliceInfo_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEveCaloData::SliceInfo_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vSliceInfo_t",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgR),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vSliceInfo_i",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEfloatcOallocatorlEfloatgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEfloatcOallocatorlEfloatgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<float>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<CellId_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEveCaloData::CellId_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vCellId_t",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgR),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vCellId_i",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<CellGeom_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEveCaloData::CellGeom_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vCellGeom_t",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgR),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vCellGeom_i",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vCellGeom_ci",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vFloat_t",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataVec));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vFloat_i",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEfloatcOallocatorlEfloatgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataVec));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vFloat_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<float,allocator<float> > >",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vvFloat_t",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataVec));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vvFloat_i",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataVec));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<PreScaleEntry_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEveProjection::PreScaleEntry_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEveCaloData::vCellId_t*>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >*>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vBinCells_t",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgR),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vBinCells_i",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TGLFont,Int_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TGLFont,int>",117,G__get_linked_tagnum(&G__G__Eve2LN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TGLFont,int,less<TGLFont> >",117,G__get_linked_tagnum(&G__G__Eve2LN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<const TGLFont*>",117,G__get_linked_tagnum(&G__G__Eve2LN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Float_t,Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_pairlEfloatcOfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Lab_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<float,float> >",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Float_t,Int_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_pairlEfloatcOintgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TM_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<float,int> >",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Cell2D_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEveCaloLegoGL::Cell2D_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vCell2D_t",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgR),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoGL));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vCell2D_i",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoGL));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<Int_t,UInt_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_maplEintcOunsignedsPintcOlesslEintgRcOallocatorlEpairlEconstsPintcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,unsigned int>",117,G__get_linked_tagnum(&G__G__Eve2LN_maplEintcOunsignedsPintcOlesslEintgRcOallocatorlEpairlEconstsPintcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,unsigned int,less<int> >",117,G__get_linked_tagnum(&G__G__Eve2LN_maplEintcOunsignedsPintcOlesslEintgRcOallocatorlEpairlEconstsPintcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("SliceDLMap_t",117,G__get_linked_tagnum(&G__G__Eve2LN_maplEintcOunsignedsPintcOlesslEintgRcOallocatorlEpairlEconstsPintcOunsignedsPintgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoGL));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("SliceDLMap_i",117,G__get_linked_tagnum(&G__G__Eve2LN_maplEintcOunsignedsPintcOlesslEintgRcOallocatorlEpairlEconstsPintcOunsignedsPintgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoGL));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<TGLOverlayElement*>",117,G__get_linked_tagnum(&G__G__Eve2LN_listlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<TGeoShape*>",117,G__get_linked_tagnum(&G__G__Eve2LN_listlETGeoShapemUcOallocatorlETGeoShapemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<Polygon_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_listlETEvePolygonSetProjectedcLcLPolygon_tcOallocatorlETEvePolygonSetProjectedcLcLPolygon_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<TEvePolygonSetProjected::Polygon_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_listlETEvePolygonSetProjectedcLcLPolygon_tcOallocatorlETEvePolygonSetProjectedcLcLPolygon_tgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vpPolygon_t",117,G__get_linked_tagnum(&G__G__Eve2LN_listlETEvePolygonSetProjectedcLcLPolygon_tcOallocatorlETEvePolygonSetProjectedcLcLPolygon_tgRsPgR),0,G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vpPolygon_i",117,G__get_linked_tagnum(&G__G__Eve2LN_listlETEvePolygonSetProjectedcLcLPolygon_tcOallocatorlETEvePolygonSetProjectedcLcLPolygon_tgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vpPolygon_ci",117,G__get_linked_tagnum(&G__G__Eve2LN_listlETEvePolygonSetProjectedcLcLPolygon_tcOallocatorlETEvePolygonSetProjectedcLcLPolygon_tgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("allocator<Int_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_allocatorlEintgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<Int_t,std::allocator<Int_t> >",117,G__get_linked_tagnum(&G__G__Eve2LN_listlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<int>",117,G__get_linked_tagnum(&G__G__Eve2LN_listlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("allocator<Polygon_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_allocatorlETEvePolygonSetProjectedcLcLPolygon_tgR),0,G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<Polygon_t,std::allocator<Polygon_t> >",117,G__get_linked_tagnum(&G__G__Eve2LN_listlETEvePolygonSetProjectedcLcLPolygon_tcOallocatorlETEvePolygonSetProjectedcLcLPolygon_tgRsPgR),0,G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TMatrixTBaselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TMatrixTBaselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TMatrixTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TMatrixTRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TMatrixTColumn_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TMatrixTDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TMatrixTFlat_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TMatrixTSub_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TMatrixTSparseRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TMatrixTSparseDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TMatrixTRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TMatrixTColumnlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TMatrixTDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TMatrixTFlatlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TMatrixTSublEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TMatrixTSparseRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TMatrixTSparseDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TElementActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TElementPosActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEvePathMarkT<Float_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TEvePathMarkTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEvePathMark",117,G__get_linked_tagnum(&G__G__Eve2LN_TEvePathMarkTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TEvePathMarkT<Double_t>",117,G__get_linked_tagnum(&G__G__Eve2LN_TEvePathMarkTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEvePathMark>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEvePathMarkT<float> >",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vPathMark_t",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vPathMark_i",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vPathMark_ci",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEveVector4>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVector4TlEfloatgRcOallocatorlETEveVector4TlEfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveVector4TlEfloatgRcOallocatorlETEveVector4TlEfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVector4TlEfloatgRcOallocatorlETEveVector4TlEfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveVector4TlEfloatgRcOallocatorlETEveVector4TlEfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVector4TlEfloatgRcOallocatorlETEveVector4TlEfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEveVector4T<float> >",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVector4TlEfloatgRcOallocatorlETEveVector4TlEfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEveVector>",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVectorTlEfloatgRcOallocatorlETEveVectorTlEfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveVectorTlEfloatgRcOallocatorlETEveVectorTlEfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVectorTlEfloatgRcOallocatorlETEveVectorTlEfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveVectorTlEfloatgRcOallocatorlETEveVectorTlEfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVectorTlEfloatgRcOallocatorlETEveVectorTlEfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TEveVectorT<float> >",117,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVectorTlEfloatgRcOallocatorlETEveVectorTlEfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TEveArrow */
static void G__setup_memvarTEveArrow(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrow));
   { TEveArrow *p; p=(TEveArrow*)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,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTubeR=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fConeR=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fConeL=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fOrigin=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fVector=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDrawQuality=",0,"Number of segments of circles.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveArrowEditor */
static void G__setup_memvarTEveArrowEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowEditor));
   { TEveArrowEditor *p; p=(TEveArrowEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveArrow),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fTubeR=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fConeR=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fConeL=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGTriVecValuator),-1,-1,2,"fOrigin=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGTriVecValuator),-1,-1,2,"fVector=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveArrowGL */
static void G__setup_memvarTEveArrowGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowGL));
   { TEveArrowGL *p; p=(TEveArrowGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveArrow),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveBox */
static void G__setup_memvarTEveBox(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBox));
   { TEveBox *p; p=(TEveBox*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fVertices[8][3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveBoxProjected */
static void G__setup_memvarTEveBoxProjected(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjected));
   { TEveBoxProjected *p; p=(TEveBoxProjected*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgR),G__defined_typename("vVector2_t"),-1,2,"fPoints=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fBreakIdx=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgR),G__defined_typename("vVector2_t"),-1,2,"fDebugPoints=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgDebugCornerPoints=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveBoxGL */
static void G__setup_memvarTEveBoxGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxGL));
   { TEveBoxGL *p; p=(TEveBoxGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveBox),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveBoxProjectedGL */
static void G__setup_memvarTEveBoxProjectedGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjectedGL));
   { TEveBoxProjectedGL *p; p=(TEveBoxProjectedGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjected),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveShape */
static void G__setup_memvarTEveShape(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShape));
   { TEveShape *p; p=(TEveShape*)0x1000; if (p) { }
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fFillColor=",0,"fill color of polygons");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fLineColor=",0,"outline color of polygons");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fLineWidth=",0,"outline width of polygons");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDrawFrame=",0,"draw frame");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHighlightFrame=",0,"highlight frame / all shape");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMiniFrame=",0,"draw minimal frame");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveShapeEditor */
static void G__setup_memvarTEveShapeEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShapeEditor));
   { TEveShapeEditor *p; p=(TEveShapeEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveShape),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGNumberEntry),-1,-1,2,"fLineWidth=",0,"Line width widget.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGColorSelect),-1,-1,2,"fLineColor=",0,"Line color widget.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fDrawFrame=",0,"Checkbox for frame rendering.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fHighlightFrame=",0,"Checkbox for frame rendering.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveFrameBox */
static void G__setup_memvarTEveFrameBox(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBox));
   { TEveFrameBox *p; p=(TEveFrameBox*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBoxcLcLEFrameType_e),-1,-2,1,G__FastAllocString(2048).Format("kFT_None=%lldLL",(long long)TEveFrameBox::kFT_None).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBoxcLcLEFrameType_e),-1,-2,1,G__FastAllocString(2048).Format("kFT_Quad=%lldLL",(long long)TEveFrameBox::kFT_Quad).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBoxcLcLEFrameType_e),-1,-2,1,G__FastAllocString(2048).Format("kFT_Box=%lldLL",(long long)TEveFrameBox::kFT_Box).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBoxcLcLEFrameType_e),-1,-1,2,"fFrameType=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fFrameSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fFramePoints=",0,"[fFrameSize]");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fFrameWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fFrameColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fBackColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fFrameRGBA[4]=",0,(char*)NULL);
   G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fBackRGBA[4]=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFrameFill=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDrawBack=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveFrameBoxGL */
static void G__setup_memvarTEveFrameBoxGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBoxGL));
   { TEveFrameBoxGL *p; p=(TEveFrameBoxGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveRGBAPalette */
static void G__setup_memvarTEveRGBAPalette(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette));
   { TEveRGBAPalette *p; p=(TEveRGBAPalette*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalettecLcLELimitAction_e),-1,-2,1,G__FastAllocString(2048).Format("kLA_Cut=%lldLL",(long long)TEveRGBAPalette::kLA_Cut).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalettecLcLELimitAction_e),-1,-2,1,G__FastAllocString(2048).Format("kLA_Mark=%lldLL",(long long)TEveRGBAPalette::kLA_Mark).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalettecLcLELimitAction_e),-1,-2,1,G__FastAllocString(2048).Format("kLA_Clip=%lldLL",(long long)TEveRGBAPalette::kLA_Clip).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalettecLcLELimitAction_e),-1,-2,1,G__FastAllocString(2048).Format("kLA_Wrap=%lldLL",(long long)TEveRGBAPalette::kLA_Wrap).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLowLimit=",0,"Low  limit for Min/Max values (used by editor)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fHighLimit=",0,"High limit for Min/Max values (used by editor)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMinVal=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxVal=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInterpolate=",0,"Interpolate colors for signal values.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowDefValue=",0,"Flags whether signals with default value should be shown.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFixColorRange=",0,"If true, map palette to low/high limit otherwise to min/max value.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fUnderflowAction=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOverflowAction=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fDefaultColor=",0,"Color for when value is not specified");
   G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fDefaultRGBA[4]=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fUnderColor=",0,"Underflow color");
   G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fUnderRGBA[4]=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fOverColor=",0,"Overflow color");
   G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fOverRGBA[4]=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNBins=",0,"Number of signal-color entries.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCAMin=",0,"Minimal signal in color-array.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCAMax=",0,"Maximal signal in color-array.");
   G__memvar_setup((void*)0,66,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fColorArray=",0,"[4*fNBins]");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette),-1,-2,2,"fgDefaultPalette=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveRGBAPaletteEditor */
static void G__setup_memvarTEveRGBAPaletteEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteEditor));
   { TEveRGBAPaletteEditor *p; p=(TEveRGBAPaletteEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette),-1,-1,2,"fM=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteSubEditor),-1,-1,2,"fSE=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveRGBAPaletteSubEditor */
static void G__setup_memvarTEveRGBAPaletteSubEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteSubEditor));
   { TEveRGBAPaletteSubEditor *p; p=(TEveRGBAPaletteSubEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette),-1,-1,2,"fM=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGComboBox),-1,-1,2,"fUnderflowAction=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGColorSelect),-1,-1,2,"fUnderColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGComboBox),-1,-1,2,"fOverflowAction=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGColorSelect),-1,-1,2,"fOverColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGDoubleValuator),-1,-1,2,"fMinMax=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fInterpolate=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fShowDefValue=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGColorSelect),-1,-1,2,"fDefaultColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fFixColorRange=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveDigitSet */
static void G__setup_memvarTEveDigitSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSet));
   { TEveDigitSet *p; p=(TEveDigitSet*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetcLcLERenderMode_e),-1,-2,1,G__FastAllocString(2048).Format("kRM_AsIs=%lldLL",(long long)TEveDigitSet::kRM_AsIs).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetcLcLERenderMode_e),-1,-2,1,G__FastAllocString(2048).Format("kRM_Line=%lldLL",(long long)TEveDigitSet::kRM_Line).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetcLcLERenderMode_e),-1,-2,1,G__FastAllocString(2048).Format("kRM_Fill=%lldLL",(long long)TEveDigitSet::kRM_Fill).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TRefArray),-1,-1,2,"fDigitIds=",0,"Array holding references to external objects.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDefaultValue=",0,"Default signal value.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fValueIsColor=",0,"Interpret signal value as RGBA color.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSingleColor=",0,"Use the same color for all digits.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAntiFlick=",0,"Make extra render pass to avoid flickering when quads are too small.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOwnIds=",0,"Flag specifying if id-objects are owned by the TEveDigitSet.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveChunkManager),-1,-1,2,"fPlex=",0,"Container of digit data.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetcLcLDigitBase_t),-1,-1,2,"fLastDigit=",0,"! The last / current digit added to collection.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLastIdx=",0,"! The last / current idx added to collection.");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fColor=",0,"Color used for frame (or all digis with single-color).");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBox),-1,-1,2,"fFrame=",0,"Pointer to frame structure.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette),-1,-1,2,"fPalette=",0,"Pointer to signal-color palette.");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetcLcLERenderMode_e),-1,-1,2,"fRenderMode=",0,"Render mode: as-is / line / filled.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDisableLighting=",0,"Disable lighting for rendering.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHistoButtons=",0,"Show histogram buttons in object editor.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEmitSignals=",0,"Emit signals on secondary-select.");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("Callback_foo"),-1,2,"fCallbackFoo=",0,"! Additional function to call on secondary-select.");
   G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("TooltipCB_foo"),-1,2,"fTooltipCBFoo=",0,"! Function providing highlight tooltips when always-sec-select is active.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveDigitSetEditor */
static void G__setup_memvarTEveDigitSetEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetEditor));
   { TEveDigitSetEditor *p; p=(TEveDigitSetEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSet),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteSubEditor),-1,-1,2,"fPalette=",0,"Palette sub-editor.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGHorizontalFrame),-1,-1,2,"fHistoButtFrame=",0,"Frame holding histogram display buttons.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGVerticalFrame),-1,-1,2,"fInfoFrame=",0,"Frame displaying basic digit statistics.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveDigitSetGL */
static void G__setup_memvarTEveDigitSetGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetGL));
   { TEveDigitSetGL *p; p=(TEveDigitSetGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Eve2LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR),G__defined_typename("set<Int_t>"),-1,2,"fHighlightSet=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveBoxSet */
static void G__setup_memvarTEveBoxSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSet));
   { TEveBoxSet *p; p=(TEveBoxSet*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSetcLcLEBoxType_e),-1,-2,1,G__FastAllocString(2048).Format("kBT_Undef=%lldLL",(long long)TEveBoxSet::kBT_Undef).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSetcLcLEBoxType_e),-1,-2,1,G__FastAllocString(2048).Format("kBT_FreeBox=%lldLL",(long long)TEveBoxSet::kBT_FreeBox).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSetcLcLEBoxType_e),-1,-2,1,G__FastAllocString(2048).Format("kBT_AABox=%lldLL",(long long)TEveBoxSet::kBT_AABox).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSetcLcLEBoxType_e),-1,-2,1,G__FastAllocString(2048).Format("kBT_AABoxFixedDim=%lldLL",(long long)TEveBoxSet::kBT_AABoxFixedDim).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSetcLcLEBoxType_e),-1,-2,1,G__FastAllocString(2048).Format("kBT_Cone=%lldLL",(long long)TEveBoxSet::kBT_Cone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSetcLcLEBoxType_e),-1,-2,1,G__FastAllocString(2048).Format("kBT_EllipticCone=%lldLL",(long long)TEveBoxSet::kBT_EllipticCone).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSetcLcLEBoxType_e),-1,-1,2,"fBoxType=",0,"Type of rendered box.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDefWidth=",0,"Breadth assigned to first coordinate  (A).");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDefHeight=",0,"Breadth assigned to second coordinate (B).");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDefDepth=",0,"Breadth assigned to third coordinate  (C).");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDrawConeCap=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveBoxSetGL */
static void G__setup_memvarTEveBoxSetGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSetGL));
   { TEveBoxSetGL *p; p=(TEveBoxSetGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSet),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fBoxDL=",0,"Display-list id for a box atom.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCaloData */
static void G__setup_memvarTEveCaloData(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData));
   { TEveCaloData *p; p=(TEveCaloData*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgR),G__defined_typename("vSliceInfo_t"),-1,2,"fSliceInfos=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TAxis),-1,-1,2,"fEtaAxis=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TAxis),-1,-1,2,"fPhiAxis=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fWrapTwoPi=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMaxValEt=",0,"cached");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMaxValE=",0,"cached");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fEps=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgR),G__defined_typename("vCellId_t"),-1,2,"fCellsSelected=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgR),G__defined_typename("vCellId_t"),-1,2,"fCellsHighlighted=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCaloData::SliceInfo_t */
static void G__setup_memvarTEveCaloDatacLcLSliceInfo_t(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDatacLcLSliceInfo_t));
   { TEveCaloData::SliceInfo_t *p; p=(TEveCaloData::SliceInfo_t*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fName)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TString),-1,-1,1,"fName=",0,"Name of the slice, eg. ECAL, HCAL.");
   G__memvar_setup((void*)((long)(&p->fThreshold)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fThreshold=",0,"Only display towers with higher energy.");
   G__memvar_setup((void*)((long)(&p->fColor)-(long)(p)),115,0,0,-1,G__defined_typename("Color_t"),-1,1,"fColor=",0,"Color used to draw this longitudinal slice.");
   G__memvar_setup((void*)((long)(&p->fTransparency)-(long)(p)),115,0,0,-1,G__defined_typename("Color_t"),-1,1,"fTransparency=",0,"Transparency used to draw this longitudinal slice.");
   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__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCaloDataVec */
static void G__setup_memvarTEveCaloDataVec(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataVec));
   { TEveCaloDataVec *p; p=(TEveCaloDataVec*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),G__defined_typename("vvFloat_t"),-1,2,"fSliceVec=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgR),G__defined_typename("vCellGeom_t"),-1,2,"fGeomVec=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTower=",0,"current tower");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fEtaMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fEtaMax=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPhiMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPhiMax=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCaloDataHist */
static void G__setup_memvarTEveCaloDataHist(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataHist));
   { TEveCaloDataHist *p; p=(TEveCaloDataHist*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_THStack),-1,-1,2,"fHStack=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCaloViz */
static void G__setup_memvarTEveCaloViz(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloViz));
   { TEveCaloViz *p; p=(TEveCaloViz*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData),-1,-1,2,"fData=",0,"event data reference");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fCellIdCacheOK=",0,"data cell ids cache state");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEtaMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fEtaMax=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhiOffset=",0,"phi range +/- offset");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAutoRange=",0,"set eta phi limits on DataChanged()");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fBarrelRadius=",0,"barrel raidus in cm");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fEndCapPos=",0,"end cap z coordinate in cm");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPlotEt=",0,"plot E or Et.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMaxTowerH=",0,"bounding box z dimesion");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fScaleAbs=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMaxValAbs=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fValueIsColor=",0,"Interpret signal value as RGBA color.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette),-1,-1,2,"fPalette=",0,"Pointer to signal-color palette.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCaloVizEditor */
static void G__setup_memvarTEveCaloVizEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloVizEditor));
   { TEveCaloVizEditor *p; p=(TEveCaloVizEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloViz),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGNumberEntry),-1,-1,2,"fFrameTransparency=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGRadioButton),-1,-1,2,"fPlotE=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGRadioButton),-1,-1,2,"fPlotEt=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fScaleAbs=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fMaxValAbs=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fMaxTowerH=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGDoubleValuator),-1,-1,2,"fEtaRng=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fPhi=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fPhiOffset=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGVerticalFrame),-1,-1,2,"fDataFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGVerticalFrame),-1,-1,2,"fSliceFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCalo3D */
static void G__setup_memvarTEveCalo3D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3D));
   { TEveCalo3D *p; p=(TEveCalo3D*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgR),G__defined_typename("vCellId_t"),-1,2,"fCellList=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrEndCapFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrBarrelFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fFrameWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fFrameColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,99,0,0,-1,G__defined_typename("Char_t"),-1,2,"fFrameTransparency=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCalo3DGL */
static void G__setup_memvarTEveCalo3DGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DGL));
   { TEveCalo3DGL *p; p=(TEveCalo3DGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3D),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,2,"fOffset=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCalo2D */
static void G__setup_memvarTEveCalo2D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D));
   { TEveCalo2D *p; p=(TEveCalo2D*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveProjectioncLcLEPType_e),-1,-1,4,"fOldProjectionType=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgR),G__defined_typename("vector<TEveCaloData::vCellId_t*>"),-1,2,"fCellLists=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgR),G__defined_typename("vector<TEveCaloData::vCellId_t*>"),-1,2,"fCellListsSelected=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgR),G__defined_typename("vector<TEveCaloData::vCellId_t*>"),-1,2,"fCellListsHighlighted=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMaxESumBin=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMaxEtSumBin=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCalo2DGL */
static void G__setup_memvarTEveCalo2DGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2DGL));
   { TEveCalo2DGL *p; p=(TEveCalo2DGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCaloLego */
static void G__setup_memvarTEveCaloLego(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego));
   { TEveCaloLego *p; p=(TEveCaloLego*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegocLcLEProjection_e),-1,-2,1,G__FastAllocString(2048).Format("kAuto=%lldLL",(long long)TEveCaloLego::kAuto).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegocLcLEProjection_e),-1,-2,1,G__FastAllocString(2048).Format("k3D=%lldLL",(long long)TEveCaloLego::k3D).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegocLcLEProjection_e),-1,-2,1,G__FastAllocString(2048).Format("k2D=%lldLL",(long long)TEveCaloLego::k2D).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegocLcLE2DMode_e),-1,-2,1,G__FastAllocString(2048).Format("kValColor=%lldLL",(long long)TEveCaloLego::kValColor).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegocLcLE2DMode_e),-1,-2,1,G__FastAllocString(2048).Format("kValSize=%lldLL",(long long)TEveCaloLego::kValSize).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegocLcLE2DMode_e),-1,-2,1,G__FastAllocString(2048).Format("kValSizeOutline=%lldLL",(long long)TEveCaloLego::kValSizeOutline).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegocLcLEBoxMode_e),-1,-2,1,G__FastAllocString(2048).Format("kNone=%lldLL",(long long)TEveCaloLego::kNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegocLcLEBoxMode_e),-1,-2,1,G__FastAllocString(2048).Format("kFrontBack=%lldLL",(long long)TEveCaloLego::kFrontBack).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegocLcLEBoxMode_e),-1,-2,1,G__FastAllocString(2048).Format("kBack=%lldLL",(long long)TEveCaloLego::kBack).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgR),G__defined_typename("vCellId_t"),-1,2,"fCellList=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fFontColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fGridColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fPlaneColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,99,0,0,-1,G__defined_typename("Char_t"),-1,2,"fPlaneTransparency=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNZSteps=",0,"Z axis label step in GeV");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fZAxisStep=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAutoRebin=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPixelsPerBin=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fNormalizeRebin=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegocLcLEProjection_e),-1,-1,2,"fProjection=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegocLcLE2DMode_e),-1,-1,2,"f2DMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegocLcLEBoxMode_e),-1,-1,2,"fBoxMode=",0,"additional scale info");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDrawHPlane=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fHPlaneVal=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHasFixedHeightIn2DMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fFixedHeightValIn2DMode=",0,"1% of whole height");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDrawNumberCellPixels=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCellPixelFontSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCaloLegoGL */
static void G__setup_memvarTEveCaloLegoGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoGL));
   { TEveCaloLegoGL *p; p=(TEveCaloLegoGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fGridColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,4,"fFontColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TAxis),-1,-1,4,"fEtaAxis=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TAxis),-1,-1,4,"fPhiAxis=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TAxis),-1,-1,4,"fZAxis=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,4,"fXAxisTitlePos=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,4,"fYAxisTitlePos=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,4,"fZAxisTitlePos=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,4,"fBackPlaneXConst[2]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,4,"fBackPlaneYConst[2]=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGLAxisPainter),-1,-1,4,"fAxisPainter=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego),-1,-1,4,"fM=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDLCacheOK=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgR),G__defined_typename("vCell2D_t"),-1,4,"fCells2D=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDatacLcLRebinData_t),-1,-1,4,"fRebinData=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fMaxVal=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fValToPixel=",0,"top logaritmic viewview");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCurrentPixelsPerBin=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_maplEintcOunsignedsPintcOlesslEintgRcOallocatorlEpairlEconstsPintcOunsignedsPintgRsPgRsPgR),G__defined_typename("SliceDLMap_t"),-1,4,"fDLMap=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fCells3D=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fBinStep=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCaloLegoOverlay */
static void G__setup_memvarTEveCaloLegoOverlay(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoOverlay));
   { TEveCaloLegoOverlay *p; p=(TEveCaloLegoOverlay*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego),-1,-1,2,"fCalo=",0,"model");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowScales=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fScaleColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,99,0,0,-1,G__defined_typename("Char_t"),-1,2,"fScaleTransparency=",0,"transaprency in %");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fScaleCoordX=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fScaleCoordY=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fScaleW=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fScaleH=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCellX=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCellY=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fFrameColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,99,0,0,-1,G__defined_typename("Char_t"),-1,2,"fFrameLineTransp=",0,(char*)NULL);
   G__memvar_setup((void*)0,99,0,0,-1,G__defined_typename("Char_t"),-1,2,"fFrameBgTransp=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMouseX=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMouseY=",0,"! last mouse position");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInDrag=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TString),-1,-1,2,"fHeaderTxt=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHeaderSelected=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TAxis),-1,-1,2,"fPlaneAxis=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fAxisPlaneColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fShowPlane=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMenuW=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fButtonW=",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,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fSliderH=",0,"slider height in % of viewport");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fSliderPosY=",0,"y position of slider bottom up");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fSliderVal=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fActiveID=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fActiveCol=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCaloLegoEditor */
static void G__setup_memvarTEveCaloLegoEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoEditor));
   { TEveCaloLegoEditor *p; p=(TEveCaloLegoEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGColorSelect),-1,-1,2,"fGridColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGColorSelect),-1,-1,2,"fFontColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGColorSelect),-1,-1,2,"fPlaneColor=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGNumberEntry),-1,-1,2,"fTransparency=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGComboBox),-1,-1,2,"fProjection=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGComboBox),-1,-1,2,"f2DMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGComboBox),-1,-1,2,"fBoxMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fCell2DTextMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGVerticalFrame),-1,-1,2,"fRebinFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fAutoRebin=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fPixelsPerBin=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fNormalizeRebin=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveCalo3DEditor */
static void G__setup_memvarTEveCalo3DEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DEditor));
   { TEveCalo3DEditor *p; p=(TEveCalo3DEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3D),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGNumberEntry),-1,-1,2,"fFrameTransparency=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGeoNode */
static void G__setup_memvarTEveGeoNode(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNode));
   { TEveGeoNode *p; p=(TEveGeoNode*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGeoNode),-1,-1,2,"fNode=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgCSGExportNSeg=",0,"!");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_listlETGeoShapemUcOallocatorlETGeoShapemUgRsPgR),G__defined_typename("list<TGeoShape*>"),-2,2,"fgTemporaryStore=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGeoTopNode */
static void G__setup_memvarTEveGeoTopNode(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNode));
   { TEveGeoTopNode *p; p=(TEveGeoTopNode*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGeoManager),-1,-1,2,"fManager=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVisOption=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVisLevel=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxVisNodes=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGeoNodeEditor */
static void G__setup_memvarTEveGeoNodeEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNodeEditor));
   { TEveGeoNodeEditor *p; p=(TEveGeoNodeEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNode),-1,-1,2,"fNodeRE=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fVizNode=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fVizNodeDaughters=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fVizVolume=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fVizVolumeDaughters=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGeoTopNodeEditor */
static void G__setup_memvarTEveGeoTopNodeEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNodeEditor));
   { TEveGeoTopNodeEditor *p; p=(TEveGeoTopNodeEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNode),-1,-1,2,"fTopNodeRE=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fVisOption=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fVisLevel=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fMaxVisNodes=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGeoShapeExtract */
static void G__setup_memvarTEveGeoShapeExtract(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeExtract));
   { TEveGeoShapeExtract *p; p=(TEveGeoShapeExtract*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTrans[16]=",0,"Transformation matrix, 4x4 column major.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRGBA[4]=",0,"RGBA color.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRGBALine[4]=",0,"RGBA color.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrSelf=",0,"Render this object.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrElements=",0,"Render children of this object.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrFrame=",0,"Also draw shape outline.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMiniFrame=",0,"Minimize shape outline when drawing.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGeoShape),-1,-1,2,"fShape=",0,"Shape to be drawn for this object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TList),-1,-1,2,"fElements=",0,"Children elements.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGeoShape */
static void G__setup_memvarTEveGeoShape(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShape));
   { TEveGeoShape *p; p=(TEveGeoShape*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNSegments=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGeoShape),-1,-1,2,"fShape=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGeoCompositeShape),-1,-1,2,"fCompositeShape=",0,"! Temporary holder (if passed shape is composite shape).");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGeoManager),-1,-2,2,"fgGeoMangeur=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGeoShapeProjected */
static void G__setup_memvarTEveGeoShapeProjected(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeProjected));
   { TEveGeoShapeProjected *p; p=(TEveGeoShapeProjected*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TBuffer3D),-1,-1,2,"fBuff=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGeoPolyShape */
static void G__setup_memvarTEveGeoPolyShape(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoPolyShape));
   { TEveGeoPolyShape *p; p=(TEveGeoPolyShape*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,2,"fVertices=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,2,"fPolyDesc=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fNbPols=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGridStepper */
static void G__setup_memvarTEveGridStepper(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepper));
   { TEveGridStepper *p; p=(TEveGridStepper*)0x1000; if (p) { }
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLimitArr[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fValueArr[3]=",0,"! Internal traversal variables.");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveGridSteppercLcLEStepMode_e),-1,-2,1,G__FastAllocString(2048).Format("kSM_XYZ=%lldLL",(long long)TEveGridStepper::kSM_XYZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveGridSteppercLcLEStepMode_e),-1,-2,1,G__FastAllocString(2048).Format("kSM_YXZ=%lldLL",(long long)TEveGridStepper::kSM_YXZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveGridSteppercLcLEStepMode_e),-1,-2,1,G__FastAllocString(2048).Format("kSM_XZY=%lldLL",(long long)TEveGridStepper::kSM_XZY).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGridSteppercLcLEStepMode_e),-1,-1,2,"fMode=",0,"Stepping mode, order of filling.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCx=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCy=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCz=",0,"Current positions during filling / traversal.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNx=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNy=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNz=",0,"Number of slots in each direction.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDx=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDy=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDz=",0,"Step size in each direction.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fOx=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fOy=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fOz=",0,"Initial offset for each direction.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGridStepperSubEditor */
static void G__setup_memvarTEveGridStepperSubEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperSubEditor));
   { TEveGridStepperSubEditor *p; p=(TEveGridStepperSubEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepper),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fNx=",0,"Number of slots along x.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fNy=",0,"Number of slots along y.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fNz=",0,"Number of slots along z.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fDx=",0,"Step in the x direction.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fDy=",0,"Step in the y direction.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fDz=",0,"Step in the z direction.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveGridStepperEditor */
static void G__setup_memvarTEveGridStepperEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperEditor));
   { TEveGridStepperEditor *p; p=(TEveGridStepperEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepper),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperSubEditor),-1,-1,2,"fSE=",0,"Sub-editor containg GUI controls.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveLegoEventHandler */
static void G__setup_memvarTEveLegoEventHandler(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLegoEventHandler));
   { TEveLegoEventHandler *p; p=(TEveLegoEventHandler*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveLegoEventHandlercLcLEMode_e),-1,-2,2,"kLocked=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveLegoEventHandlercLcLEMode_e),-1,-2,2,"kFree=1LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveLegoEventHandlercLcLEMode_e),-1,-1,2,"fMode=",0,"current rotation mode");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTransTheta=",0,"transition theta in radians");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTheta=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fLego)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego),-1,-1,1,"fLego=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveLine */
static void G__setup_memvarTEveLine(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLine));
   { TEveLine *p; p=(TEveLine*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrLine=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrPoints=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSmooth=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgDefaultSmooth=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveLineEditor */
static void G__setup_memvarTEveLineEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineEditor));
   { TEveLineEditor *p; p=(TEveLineEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveLine),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fRnrLine=",0,"Checkbox for line-rendering.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fRnrPoints=",0,"Checkbox for point-rendering.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fSmooth=",0,"Checkbox for line smoothing.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveLineGL */
static void G__setup_memvarTEveLineGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineGL));
   { TEveLineGL *p; p=(TEveLineGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveLine),-1,-1,2,"fM=",0,"fModel dynamic-casted to TEveLineGL");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvePointSet */
static void G__setup_memvarTEvePointSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet));
   { TEvePointSet *p; p=(TEvePointSet*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TString),-1,-1,2,"fTitle=",0,"Title/tooltip of the TEvePointSet.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TArrayI),-1,-1,2,"fIntIds=",0,"Optional array of integer ideices.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIntIdsPerPoint=",0,"Number of integer indices assigned to each point.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvePointSetArray */
static void G__setup_memvarTEvePointSetArray(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArray));
   { TEvePointSetArray *p; p=(TEvePointSetArray*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet),-1,-1,2,"fBins=",0,"Pointers to subjugated TEvePointSet's.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDefPointSetCapacity=",0,"Default capacity of subjugated TEvePointSet's.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNBins=",0,"Number of subjugated TEvePointSet's.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLastBin=",0,"! Index of the last filled TEvePointSet.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCurMin=",0,"Overall and current minimum value of the separating quantity.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMax=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCurMax=",0,"Overall and current maximum value of the separating quantity.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fBinWidth=",0,"Separating quantity bin-width.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TString),-1,-1,2,"fQuantName=",0,"Name of the separating quantity.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvePointSetArrayEditor */
static void G__setup_memvarTEvePointSetArrayEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArrayEditor));
   { TEvePointSetArrayEditor *p; p=(TEvePointSetArrayEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArray),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGDoubleValuator),-1,-1,2,"fRange=",0,"Control for displayed range of the separating quantity.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvePointSetProjected */
static void G__setup_memvarTEvePointSetProjected(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected));
   { TEvePointSetProjected *p; p=(TEvePointSetProjected*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveLineProjected */
static void G__setup_memvarTEveLineProjected(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected));
   { TEveLineProjected *p; p=(TEveLineProjected*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvePolygonSetProjected */
static void G__setup_memvarTEvePolygonSetProjected(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected));
   { TEvePolygonSetProjected *p; p=(TEvePolygonSetProjected*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TBuffer3D),-1,-1,4,"fBuff=",0,"buffer of projectable object");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_listlETEvePolygonSetProjectedcLcLPolygon_tcOallocatorlETEvePolygonSetProjectedcLcLPolygon_tgRsPgR),G__defined_typename("vpPolygon_t"),-1,2,"fPols=",0,"polygons");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_listlETEvePolygonSetProjectedcLcLPolygon_tcOallocatorlETEvePolygonSetProjectedcLcLPolygon_tgRsPgR),G__defined_typename("vpPolygon_t"),-1,2,"fPolsBS=",0,"polygons build from TBuffer3D segments");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_listlETEvePolygonSetProjectedcLcLPolygon_tcOallocatorlETEvePolygonSetProjectedcLcLPolygon_tgRsPgR),G__defined_typename("vpPolygon_t"),-1,2,"fPolsBP=",0,"polygons build from TBuffer3D polygons");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNPnts=",0,"number of reduced and projected points");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fPnts=",0,"reduced and projected points");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvePolygonSetProjectedGL */
static void G__setup_memvarTEvePolygonSetProjectedGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjectedGL));
   { TEvePolygonSetProjectedGL *p; p=(TEvePolygonSetProjectedGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected),-1,-1,2,"fM=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveQuadSet */
static void G__setup_memvarTEveQuadSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet));
   { TEveQuadSet *p; p=(TEveQuadSet*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_Undef=%lldLL",(long long)TEveQuadSet::kQT_Undef).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_FreeQuad=%lldLL",(long long)TEveQuadSet::kQT_FreeQuad).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_RectangleXY=%lldLL",(long long)TEveQuadSet::kQT_RectangleXY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_RectangleXZ=%lldLL",(long long)TEveQuadSet::kQT_RectangleXZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_RectangleYZ=%lldLL",(long long)TEveQuadSet::kQT_RectangleYZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_RectangleXYFixedDim=%lldLL",(long long)TEveQuadSet::kQT_RectangleXYFixedDim).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_RectangleXYFixedZ=%lldLL",(long long)TEveQuadSet::kQT_RectangleXYFixedZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_RectangleXZFixedY=%lldLL",(long long)TEveQuadSet::kQT_RectangleXZFixedY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_RectangleYZFixedX=%lldLL",(long long)TEveQuadSet::kQT_RectangleYZFixedX).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_RectangleXYFixedDimZ=%lldLL",(long long)TEveQuadSet::kQT_RectangleXYFixedDimZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_RectangleXZFixedDimY=%lldLL",(long long)TEveQuadSet::kQT_RectangleXZFixedDimY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_RectangleYZFixedDimX=%lldLL",(long long)TEveQuadSet::kQT_RectangleYZFixedDimX).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_Rectangle_End=%lldLL",(long long)TEveQuadSet::kQT_Rectangle_End).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_LineXYFixedZ=%lldLL",(long long)TEveQuadSet::kQT_LineXYFixedZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_LineXZFixedY=%lldLL",(long long)TEveQuadSet::kQT_LineXZFixedY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_Line_End=%lldLL",(long long)TEveQuadSet::kQT_Line_End).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_HexagonXY=%lldLL",(long long)TEveQuadSet::kQT_HexagonXY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_HexagonYX=%lldLL",(long long)TEveQuadSet::kQT_HexagonYX).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-2,1,G__FastAllocString(2048).Format("kQT_Hexagon_End=%lldLL",(long long)TEveQuadSet::kQT_Hexagon_End).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e),-1,-1,2,"fQuadType=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDefWidth=",0,"Breadth assigned to first coordinate  (A)");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDefHeight=",0,"Breadth assigned to second coordinate (B)");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDefCoord=",0,"Default value for third coordinate    (C)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveQuadSetGL */
static void G__setup_memvarTEveQuadSetGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetGL));
   { TEveQuadSetGL *p; p=(TEveQuadSetGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet),-1,-1,2,"fM=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveStraightLineSet */
static void G__setup_memvarTEveStraightLineSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet));
   { TEveStraightLineSet *p; p=(TEveStraightLineSet*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveChunkManager),-1,-1,2,"fLinePlex=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveChunkManager),-1,-1,2,"fMarkerPlex=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOwnLinesIds=",0,"Flag specifying if id-objects are owned by the line-set");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOwnMarkersIds=",0,"Flag specifying if id-objects are owned by the line-set");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrMarkers=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrLines=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDepthTest=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetcLcLLine_t),-1,-1,2,"fLastLine=",0,"!");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveStraightLineSetProjected */
static void G__setup_memvarTEveStraightLineSetProjected(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected));
   { TEveStraightLineSetProjected *p; p=(TEveStraightLineSetProjected*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveScalableStraightLineSet */
static void G__setup_memvarTEveScalableStraightLineSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveScalableStraightLineSet));
   { TEveScalableStraightLineSet *p; p=(TEveScalableStraightLineSet*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCurrentScale=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fScaleCenter[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveStraightLineSetEditor */
static void G__setup_memvarTEveStraightLineSetEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetEditor));
   { TEveStraightLineSetEditor *p; p=(TEveStraightLineSetEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet),-1,-1,2,"fM=",0,"fModel dynamic-casted to TEveStraightLineSetEditor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fRnrMarkers=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fRnrLines=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveStraightLineSetGL */
static void G__setup_memvarTEveStraightLineSetGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetGL));
   { TEveStraightLineSetGL *p; p=(TEveStraightLineSetGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet),-1,-1,2,"fM=",0,"fModel dynamic-casted to TEveStraightLineSetGL");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveText */
static void G__setup_memvarTEveText(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveText));
   { TEveText *p; p=(TEveText*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TString),-1,-1,2,"fText=",0,"text");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Color_t"),-1,2,"fTextColor=",0,"text color");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fFontSize=",0,"FTFont face size");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fFontFile=",0,"FTFont file name");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fFontMode=",0,"FTFont FTGL class id");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fExtrude=",0,"extrude depth");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAutoLighting=",0,"use default lighting");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLighting=",0,"force lighting");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPolygonOffset[2]=",0,"depth test");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTextEditor */
static void G__setup_memvarTEveTextEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTextEditor));
   { TEveTextEditor *p; p=(TEveTextEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveText),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGTextEntry),-1,-1,2,"fText=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGComboBox),-1,-1,2,"fSize=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGComboBox),-1,-1,2,"fFile=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGComboBox),-1,-1,2,"fMode=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fExtrude=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fLighting=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fAutoLighting=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTextGL */
static void G__setup_memvarTEveTextGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTextGL));
   { TEveTextGL *p; p=(TEveTextGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveText),-1,-1,2,"fM=",0,"model object.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGLFont),-1,-1,2,"fFont=",0,"FTFont wrapper");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX[4][3]=",0,"3D position of font");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTrackPropagatorSubEditor */
static void G__setup_memvarTEveTrackPropagatorSubEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorSubEditor));
   { TEveTrackPropagatorSubEditor *p; p=(TEveTrackPropagatorSubEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator),-1,-1,2,"fM=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fMaxR=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fMaxZ=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fMaxOrbits=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fMaxAng=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGValuator),-1,-1,2,"fDelta=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),-1,-1,2,"fRefsCont=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCompositeFrame),-1,-1,2,"fPMFrame=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGButton),-1,-1,2,"fFitDaughters=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGButton),-1,-1,2,"fFitReferences=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGButton),-1,-1,2,"fFitDecay=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGButton),-1,-1,2,"fFitCluster2Ds=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGButton),-1,-1,2,"fRnrDaughters=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGButton),-1,-1,2,"fRnrReferences=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGButton),-1,-1,2,"fRnrDecay=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGButton),-1,-1,2,"fRnrCluster2Ds=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGButton),-1,-1,2,"fRnrFV=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TAttMarkerEditor),-1,-1,2,"fPMAtt=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TAttMarkerEditor),-1,-1,2,"fFVAtt=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGComboBox),-1,-1,2,"fProjTrackBreaking=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGButton),-1,-1,2,"fRnrPTBMarkers=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TAttMarkerEditor),-1,-1,2,"fPTBAtt=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTrack */
static void G__setup_memvarTEveTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack));
   { TEveTrack *p; p=(TEveTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackcLcLEBreakProjectedTracks_e),-1,-2,1,G__FastAllocString(2048).Format("kBPTDefault=%lldLL",(long long)TEveTrack::kBPTDefault).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackcLcLEBreakProjectedTracks_e),-1,-2,1,G__FastAllocString(2048).Format("kBPTAlways=%lldLL",(long long)TEveTrack::kBPTAlways).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackcLcLEBreakProjectedTracks_e),-1,-2,1,G__FastAllocString(2048).Format("kBPTNever=%lldLL",(long long)TEveTrack::kBPTNever).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fV=",0,"Starting vertex");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fP=",0,"Starting momentum");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fPEnd=",0,"Momentum at the last point of extrapolation");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fBeta=",0,"Relativistic beta factor");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPdg=",0,"PDG code");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCharge=",0,"Charge in units of e0");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLabel=",0,"Simulation label");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIndex=",0,"Reconstruction index");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fStatus=",0,"Status-word, user-defined.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLockPoints=",0,"Lock points that are currently in - do nothing in MakeTrack().");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgR),G__defined_typename("vPathMark_t"),-1,2,"fPathMarks=",0,"TEveVector of known points along the track");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLastPMIdx=",0,"!Last path-mark index tried in track-propagation.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator),-1,-1,2,"fPropagator=",0,"Pointer to shared render-style");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTrackList */
static void G__setup_memvarTEveTrackList(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList));
   { TEveTrackList *p; p=(TEveTrackList*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator),-1,-1,2,"fPropagator=",0,"Basic track rendering parameters, not enforced to elements.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRecurse=",0,"Recurse when propagating marker/line/etc attributes to tracks.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrLine=",0,"Render track as line.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrPoints=",0,"Render track as points.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMinPt=",0,"Minimum track pT for display selection.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMaxPt=",0,"Maximum track pT for display selection.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fLimPt=",0,"Highest track pT in the container.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMinP=",0,"Minimum track p for display selection.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMaxP=",0,"Maximum track p for display selection.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fLimP=",0,"Highest track p in the container.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTrackEditor */
static void G__setup_memvarTEveTrackEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackEditor));
   { TEveTrackEditor *p; p=(TEveTrackEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack),-1,-1,2,"fM=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGTextButton),-1,-1,2,"fRSEditor=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTrackListEditor */
static void G__setup_memvarTEveTrackListEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListEditor));
   { TEveTrackListEditor *p; p=(TEveTrackListEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGVerticalFrame),-1,-1,2,"fRefs=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList),-1,-1,2,"fTC=",0,"fModel dynamic-casted to TEveTrackListEditor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fRnrLine=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGCheckButton),-1,-1,2,"fRnrPoints=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGDoubleValuator),-1,-1,2,"fPtRange=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveGDoubleValuator),-1,-1,2,"fPRange=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorSubEditor),-1,-1,2,"fRSSubEditor=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTrackGL */
static void G__setup_memvarTEveTrackGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackGL));
   { TEveTrackGL *p; p=(TEveTrackGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack),-1,-1,2,"fTrack=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTrackPropagator */
static void G__setup_memvarTEveTrackPropagator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator));
   { TEveTrackPropagator *p; p=(TEveTrackPropagator*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorcLcLEStepper_e),-1,-2,1,G__FastAllocString(2048).Format("kHelix=%lldLL",(long long)TEveTrackPropagator::kHelix).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorcLcLEStepper_e),-1,-2,1,G__FastAllocString(2048).Format("kRungeKutta=%lldLL",(long long)TEveTrackPropagator::kRungeKutta).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorcLcLEProjTrackBreaking_e),-1,-2,1,G__FastAllocString(2048).Format("kPTB_Break=%lldLL",(long long)TEveTrackPropagator::kPTB_Break).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorcLcLEProjTrackBreaking_e),-1,-2,1,G__FastAllocString(2048).Format("kPTB_UseFirstPointPos=%lldLL",(long long)TEveTrackPropagator::kPTB_UseFirstPointPos).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorcLcLEProjTrackBreaking_e),-1,-2,1,G__FastAllocString(2048).Format("kPTB_UseLastPointPos=%lldLL",(long long)TEveTrackPropagator::kPTB_UseLastPointPos).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorcLcLEStepper_e),-1,-1,2,"fStepper=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveMagField),-1,-1,2,"fMagFieldObj=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fOwnMagFiledObj=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMaxR=",0,"Max radius for track extrapolation");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMaxZ=",0,"Max z-coordinate for track extrapolation.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNMax=",0,"Max steps");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMaxOrbs=",0,"Maximal angular path of tracks' orbits (1 ~ 2Pi).");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fEditPathMarks=",0,"Show widgets for path-mark control in GUI editor.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFitDaughters=",0,"Pass through daughter creation points when extrapolating a track.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFitReferences=",0,"Pass through given track-references when extrapolating a track.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFitDecay=",0,"Pass through decay point when extrapolating a track.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFitCluster2Ds=",0,"Pass through 2D-clusters when extrapolating a track.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrDaughters=",0,"Render daughter path-marks.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrReferences=",0,"Render track-reference path-marks.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrDecay=",0,"Render decay path-marks.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrCluster2Ds=",0,"Render 2D-clusters.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrFV=",0,"Render first vertex.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TMarker),-1,-1,2,"fPMAtt=",0,"Marker attributes for rendering of path-marks.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TMarker),-1,-1,2,"fFVAtt=",0,"Marker attributes for fits vertex.");
   G__memvar_setup((void*)0,98,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fProjTrackBreaking=",0,"Handling of projected-track breaking.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fRnrPTBMarkers=",0,"Render break-points on tracks.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TMarker),-1,-1,2,"fPTBAtt=",0,"Marker attributes for track break-points.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVector4TlEfloatgRcOallocatorlETEveVector4TlEfloatgRsPgRsPgR),G__defined_typename("vector<TEveVector4>"),-1,2,"fPoints=",0,"Calculated point.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fV=",0,"Start vertex.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorcLcLHelix_t),-1,-1,2,"fH=",0,"Helix.");
   G__memvar_setup((void*)(&TEveTrackPropagator::fgDefMagField),102,0,0,-1,G__defined_typename("Float_t"),-2,1,"fgDefMagField=",0,"Default value for constant solenoid magnetic field.");
   G__memvar_setup((void*)(&TEveTrackPropagator::fgkB2C),102,0,1,-1,G__defined_typename("Float_t"),-2,1,"fgkB2C=",0,"Constant for conversion of momentum to curvature.");
   G__memvar_setup((void*)(&TEveTrackPropagator::fgDefault),117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator),-1,-2,1,"fgDefault=",0,"Default track propagator.");
   G__memvar_setup((void*)(&TEveTrackPropagator::fgEditorMaxR),102,0,0,-1,G__defined_typename("Float_t"),-2,1,"fgEditorMaxR=",0,"Max R that can be set in GUI editor.");
   G__memvar_setup((void*)(&TEveTrackPropagator::fgEditorMaxZ),102,0,0,-1,G__defined_typename("Float_t"),-2,1,"fgEditorMaxZ=",0,"Max Z that can be set in GUI editor.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTrackProjected */
static void G__setup_memvarTEveTrackProjected(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected));
   { TEveTrackProjected *p; p=(TEveTrackProjected*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,4,"fOrigPnts=",0,"original track points");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,2,"fBreakPoints=",0,"indices of track break-points");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTrackProjectedGL */
static void G__setup_memvarTEveTrackProjectedGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjectedGL));
   { TEveTrackProjectedGL *p; p=(TEveTrackProjectedGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTrackListProjected */
static void G__setup_memvarTEveTrackListProjected(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListProjected));
   { TEveTrackListProjected *p; p=(TEveTrackListProjected*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTrackPropagatorEditor */
static void G__setup_memvarTEveTrackPropagatorEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorEditor));
   { TEveTrackPropagatorEditor *p; p=(TEveTrackPropagatorEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorSubEditor),-1,-1,2,"fRSSubEditor=",0,"Render-style sub-editor.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveMagField */
static void G__setup_memvarTEveMagField(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveMagField));
   { TEveMagField *p; p=(TEveMagField*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFieldConstant=",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__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveMagFieldConst */
static void G__setup_memvarTEveMagFieldConst(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldConst));
   { TEveMagFieldConst *p; p=(TEveMagFieldConst*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fB=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveMagFieldDuo */
static void G__setup_memvarTEveMagFieldDuo(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldDuo));
   { TEveMagFieldDuo *p; p=(TEveMagFieldDuo*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fBIn=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fBOut=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fR2=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTriangleSet */
static void G__setup_memvarTEveTriangleSet(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSet));
   { TEveTriangleSet *p; p=(TEveTriangleSet*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNVerts=",0,(char*)NULL);
   G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fVerts=",0,"[3*fNVerts]");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNTrings=",0,(char*)NULL);
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTrings=",0,"[3*fNTrings]");
   G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTringNorms=",0,"[3*fNTrings]");
   G__memvar_setup((void*)0,66,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fTringCols=",0,"[3*fNTrings]");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTriangleSetEditor */
static void G__setup_memvarTEveTriangleSetEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetEditor));
   { TEveTriangleSetEditor *p; p=(TEveTriangleSetEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSet),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGLabel),-1,-1,2,"fInfo=",0,"Info label.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveTriangleSetGL */
static void G__setup_memvarTEveTriangleSetGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetGL));
   { TEveTriangleSetGL *p; p=(TEveTriangleSetGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSet),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveJetCone */
static void G__setup_memvarTEveJetCone(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetCone));
   { TEveJetCone *p; p=(TEveJetCone*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fApex=",0,"Apex of the cone.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fAxis=",0,"Axis of the cone.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR),G__defined_typename("TEveVector"),-1,2,"fLimits=",0,"Border of Barrel/Cylinder to cut the cone.");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fThetaC=",0,"Transition theta");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fEta=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPhi=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDEta=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fDPhi=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNDiv=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveJetConeEditor */
static void G__setup_memvarTEveJetConeEditor(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeEditor));
   { TEveJetConeEditor *p; p=(TEveJetConeEditor*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveJetCone),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveJetConeProjected */
static void G__setup_memvarTEveJetConeProjected(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjected));
   { TEveJetConeProjected *p; p=(TEveJetConeProjected*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveJetConeGL */
static void G__setup_memvarTEveJetConeGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeGL));
   { TEveJetConeGL *p; p=(TEveJetConeGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveJetCone),-1,-1,2,"fC=",0,"Model object.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveVectorTlEfloatgRcOallocatorlETEveVectorTlEfloatgRsPgRsPgR),G__defined_typename("vector<TEveVector>"),-1,2,"fP=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEveJetConeProjectedGL */
static void G__setup_memvarTEveJetConeProjectedGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjectedGL));
   { TEveJetConeProjectedGL *p; p=(TEveJetConeProjectedGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjected),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvePlot3D */
static void G__setup_memvarTEvePlot3D(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3D));
   { TEvePlot3D *p; p=(TEvePlot3D*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TObject),-1,-1,2,"fPlot=",0,"Plot object.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TString),-1,-1,2,"fPlotOption=",0,"Options for the plot-painter.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLogX=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLogY=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLogZ=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TEvePlot3DGL */
static void G__setup_memvarTEvePlot3DGL(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3DGL));
   { TEvePlot3DGL *p; p=(TEvePlot3DGL*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3D),-1,-1,2,"fM=",0,"Model object.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TGLPlot3D),-1,-1,2,"fPlotLogical=",0,"Actual painter.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Eve2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__Eve2() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTEveArrow(void) {
   /* TEveArrow */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrow));
   G__memfunc_setup("TEveArrow",895,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveArrow), -1, 0, 1, 1, 4, 0, "u 'TEveArrow' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveArrow), -1, 1, 1, 1, 4, 0, "u 'TEveArrow' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveArrow",895,G__G__Eve2_230_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveArrow), -1, 0, 6, 1, 1, 0, 
"f - 'Float_t' 0 '0' xVec f - 'Float_t' 0 '0' yVec "
"f - 'Float_t' 0 '1' zVec f - 'Float_t' 0 '0' xOrg "
"f - 'Float_t' 0 '0' yOrg f - 'Float_t' 0 '0' zOrg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObject",887,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TObject), -1, 0, 1, 1, 1, 8, "u 'TEveException' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTubeR",782,G__G__Eve2_230_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetConeR",771,G__G__Eve2_230_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetConeL",765,G__G__Eve2_230_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTubeR",770,G__G__Eve2_230_0_8, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConeR",759,G__G__Eve2_230_0_9, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConeL",753,G__G__Eve2_230_0_10, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVector",915,G__G__Eve2_230_0_11, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR), G__defined_typename("TEveVector"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOrigin",904,G__G__Eve2_230_0_12, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR), G__defined_typename("TEveVector"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawQuality",1431,G__G__Eve2_230_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawQuality",1443,G__G__Eve2_230_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - q", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (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("Class",502,G__G__Eve2_230_0_17, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveArrow::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_230_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveArrow::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_230_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveArrow::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_230_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveArrow::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_230_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__Eve2_230_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveArrow::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_230_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveArrow::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_230_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveArrow::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_230_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveArrow::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveArrow", 1021, G__G__Eve2_230_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveArrowEditor(void) {
   /* TEveArrowEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowEditor));
   G__memfunc_setup("TEveArrowEditor",1510,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowEditor), -1, 0, 1, 1, 4, 0, "u 'TEveArrowEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowEditor), -1, 1, 1, 1, 4, 0, "u 'TEveArrowEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveArrowEditor",1510,G__G__Eve2_232_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowEditor), -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("DoTubeR",661,G__G__Eve2_232_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoConeR",650,G__G__Eve2_232_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoConeL",644,G__G__Eve2_232_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoVertex",817,G__G__Eve2_232_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_232_0_9, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveArrowEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_232_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveArrowEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_232_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveArrowEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_232_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveArrowEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_232_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__Eve2_232_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveArrowEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_232_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveArrowEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_232_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveArrowEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_232_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveArrowEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveArrowEditor", 1636, G__G__Eve2_232_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveArrowGL(void) {
   /* TEveArrowGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowGL));
   G__memfunc_setup("TEveArrowGL",1042,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowGL), -1, 0, 1, 1, 4, 0, "u 'TEveArrowGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowGL), -1, 1, 1, 1, 4, 0, "u 'TEveArrowGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveArrowGL",1042,G__G__Eve2_316_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveArrowGL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBBox",663,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_316_0_7, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveArrowGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_316_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveArrowGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_316_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveArrowGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_316_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveArrowGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_316_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__Eve2_316_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveArrowGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_316_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveArrowGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_316_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveArrowGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_316_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveArrowGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveArrowGL", 1168, G__G__Eve2_316_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveBox(void) {
   /* TEveBox */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBox));
   G__memfunc_setup("TEveBox",669,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveBox), -1, 0, 1, 1, 4, 0, "u 'TEveBox' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveBox), -1, 1, 1, 1, 4, 0, "u 'TEveBox' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveBox",669,G__G__Eve2_383_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveBox), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEveBox\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVertex",938,G__G__Eve2_383_0_4, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - i f - 'Float_t' 0 - x "
"f - 'Float_t' 0 - y f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVertex",938,G__G__Eve2_383_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - i F - 'Float_t' 10 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVertices",1137,G__G__Eve2_383_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - vs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVertex",926,G__G__Eve2_383_0_7, 70, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProjectedClass",1430,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 1, 1, 1, 8, "U 'TEveProjection' - 10 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_383_0_10, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveBox::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_383_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBox::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_383_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveBox::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_383_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveBox::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_383_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__Eve2_383_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBox::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_383_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveBox::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_383_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBox::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_383_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveBox::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveBox", 795, G__G__Eve2_383_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveBoxProjected(void) {
   /* TEveBoxProjected */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjected));
   G__memfunc_setup("TEveBoxProjected",1597,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjected), -1, 0, 1, 1, 4, 0, "u 'TEveBoxProjected' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjected), -1, 1, 1, 1, 4, 0, "u 'TEveBoxProjected' - 11 - -", "Not implemented", (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("TEveBoxProjected",1597,G__G__Eve2_384_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjected), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEveBoxProjected\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetProjection",1353,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveProjectionManager' - 0 - mng U 'TEveProjectable' - 0 - model", (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__Eve2LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDebugCornerPoints",2029,G__G__Eve2_384_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TEveBoxProjected::GetDebugCornerPoints) ), 0);
   G__memfunc_setup("SetDebugCornerPoints",2041,G__G__Eve2_384_0_10, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - d", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TEveBoxProjected::SetDebugCornerPoints) ), 0);
   G__memfunc_setup("Class",502,G__G__Eve2_384_0_11, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveBoxProjected::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_384_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBoxProjected::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_384_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveBoxProjected::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_384_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveBoxProjected::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_384_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__Eve2_384_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBoxProjected::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_384_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveBoxProjected::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_384_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBoxProjected::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_384_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveBoxProjected::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveBoxProjected", 1723, G__G__Eve2_384_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveBoxGL(void) {
   /* TEveBoxGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxGL));
   G__memfunc_setup("TEveBoxGL",816,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxGL), -1, 0, 1, 1, 4, 0, "u 'TEveBoxGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxGL), -1, 1, 1, 1, 4, 0, "u 'TEveBoxGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("RenderOutline",1344,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "f - 'Float_t' 10 - p[][3]", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderBoxStdNorm",1616,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "f - 'Float_t' 10 - p[][3]", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderBoxAutoNorm",1726,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "f - 'Float_t' 10 - p[][3]", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveBoxGL",816,G__G__Eve2_385_0_6, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxGL), -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__Eve2_385_0_12, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveBoxGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_385_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBoxGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_385_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveBoxGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_385_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveBoxGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_385_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__Eve2_385_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBoxGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_385_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveBoxGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_385_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBoxGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_385_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveBoxGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveBoxGL", 942, G__G__Eve2_385_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveBoxProjectedGL(void) {
   /* TEveBoxProjectedGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjectedGL));
   G__memfunc_setup("TEveBoxProjectedGL",1744,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjectedGL), -1, 0, 1, 1, 4, 0, "u 'TEveBoxProjectedGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjectedGL), -1, 1, 1, 1, 4, 0, "u 'TEveBoxProjectedGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("RenderPoints",1245,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveBoxProjectedGL",1744,G__G__Eve2_386_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxProjectedGL), -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__Eve2_386_0_10, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveBoxProjectedGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_386_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBoxProjectedGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_386_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveBoxProjectedGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_386_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveBoxProjectedGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_386_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__Eve2_386_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBoxProjectedGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_386_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveBoxProjectedGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_386_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBoxProjectedGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_386_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveBoxProjectedGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveBoxProjectedGL", 1870, G__G__Eve2_386_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveShape(void) {
   /* TEveShape */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShape));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveShape), -1, 1, 1, 1, 4, 0, "u 'TEveShape' - 11 - -", "Not implemented", (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("GetFillColor",1190,G__G__Eve2_390_0_5, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLineColor",1191,G__G__Eve2_390_0_6, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLineWidth",1192,G__G__Eve2_390_0_7, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDrawFrame",1177,G__G__Eve2_390_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHighlightFrame",1699,G__G__Eve2_390_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMiniFrame",1176,G__G__Eve2_390_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFillColor",1202,G__G__Eve2_390_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineColor",1203,G__G__Eve2_390_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineWidth",1204,G__G__Eve2_390_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - lw", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDrawFrame",1189,G__G__Eve2_390_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHighlightFrame",1711,G__G__Eve2_390_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMiniFrame",1188,G__G__Eve2_390_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - r", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyVizParams",1336,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 10 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteVizParams",1448,(G__InterfaceMethod) NULL,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("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("FindConvexHull",1417,G__G__Eve2_390_0_20, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
"u 'vector<TEveVector2T<float>,allocator<TEveVector2T<float> > >' 'TEveShape::vVector2_t' 11 - pin u 'vector<TEveVector2T<float>,allocator<TEveVector2T<float> > >' 'TEveShape::vVector2_t' 1 - pout "
"U 'TEveElement' - 0 '0' caller", (char*)NULL, (void*) G__func2void( (Int_t (*)(const TEveShape::vVector2_t&, TEveShape::vVector2_t&, TEveElement*))(&TEveShape::FindConvexHull) ), 0);
   G__memfunc_setup("IsBoxOrientationConsistentEv",2902,G__G__Eve2_390_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 1, 3, 1, 0, "U 'TEveVectorT<float>' 'TEveVector' 10 - box", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const TEveVector*))(&TEveShape::IsBoxOrientationConsistentEv) ), 0);
   G__memfunc_setup("IsBoxOrientationConsistentFv",2903,G__G__Eve2_390_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 1, 3, 1, 0, "F - 'Float_t' 12 - box", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const Float_t**))(&TEveShape::IsBoxOrientationConsistentFv) ), 0);
   G__memfunc_setup("CheckAndFixBoxOrientationEv",2696,G__G__Eve2_390_0_23, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TEveVectorT<float>' 'TEveVector' 0 - box", (char*)NULL, (void*) G__func2void( (void (*)(TEveVector*))(&TEveShape::CheckAndFixBoxOrientationEv) ), 0);
   G__memfunc_setup("CheckAndFixBoxOrientationFv",2697,G__G__Eve2_390_0_24, 121, -1, -1, 0, 1, 3, 1, 0, "F - 'Float_t' 2 - box", (char*)NULL, (void*) G__func2void( (void (*)(Float_t**))(&TEveShape::CheckAndFixBoxOrientationFv) ), 0);
   G__memfunc_setup("Class",502,G__G__Eve2_390_0_25, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveShape::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_390_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveShape::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_390_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveShape::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_390_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveShape::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_390_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__Eve2_390_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveShape::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_390_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveShape::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_390_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveShape::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_390_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveShape::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveShape", 995, G__G__Eve2_390_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveShapeEditor(void) {
   /* TEveShapeEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveShapeEditor));
   G__memfunc_setup("TEveShapeEditor",1484,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveShapeEditor), -1, 0, 1, 1, 4, 0, "u 'TEveShapeEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveShapeEditor), -1, 1, 1, 1, 4, 0, "u 'TEveShapeEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveShapeEditor",1484,G__G__Eve2_391_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveShapeEditor), -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("DoLineWidth",1083,G__G__Eve2_391_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoLineColor",1082,G__G__Eve2_391_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDrawFrame",1068,G__G__Eve2_391_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoHighlightFrame",1590,G__G__Eve2_391_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_391_0_9, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveShapeEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_391_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveShapeEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_391_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveShapeEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_391_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveShapeEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_391_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__Eve2_391_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveShapeEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_391_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveShapeEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_391_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveShapeEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_391_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveShapeEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveShapeEditor", 1610, G__G__Eve2_391_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveFrameBox(void) {
   /* TEveFrameBox */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBox));
   G__memfunc_setup("TEveFrameBox",1160,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBox), -1, 0, 1, 1, 4, 0, "u 'TEveFrameBox' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBox), -1, 1, 1, 1, 4, 0, "u 'TEveFrameBox' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveFrameBox",1160,G__G__Eve2_396_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBox), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAAQuadXY",1002,G__G__Eve2_396_0_4, 121, -1, -1, 0, 5, 1, 1, 0, 
"f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
"f - 'Float_t' 0 - z f - 'Float_t' 0 - dx "
"f - 'Float_t' 0 - dy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAAQuadXZ",1003,G__G__Eve2_396_0_5, 121, -1, -1, 0, 5, 1, 1, 0, 
"f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
"f - 'Float_t' 0 - z f - 'Float_t' 0 - dx "
"f - 'Float_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetQuadByPoints",1519,G__G__Eve2_396_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"F - 'Float_t' 10 - pointArr i - 'Int_t' 0 - nPoints", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAABox",727,G__G__Eve2_396_0_7, 121, -1, -1, 0, 6, 1, 1, 0, 
"f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
"f - 'Float_t' 0 - z f - 'Float_t' 0 - dx "
"f - 'Float_t' 0 - dy f - 'Float_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAABoxCenterHalfSize",2126,G__G__Eve2_396_0_8, 121, -1, -1, 0, 6, 1, 1, 0, 
"f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
"f - 'Float_t' 0 - z f - 'Float_t' 0 - dx "
"f - 'Float_t' 0 - dy f - 'Float_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameType",1197,G__G__Eve2_396_0_9, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBoxcLcLEFrameType_e), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameSize",1190,G__G__Eve2_396_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFramePoints",1416,G__G__Eve2_396_0_11, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameWidth",1291,G__G__Eve2_396_0_12, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameWidth",1303,G__G__Eve2_396_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameColor",1290,G__G__Eve2_396_0_14, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PtrFrameColor",1312,G__G__Eve2_396_0_15, 83, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameRGBA",1063,G__G__Eve2_396_0_16, 66, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameColor",1302,G__G__Eve2_396_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - ci", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameColorPixel",1816,G__G__Eve2_396_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - pix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameColorRGBA",1586,G__G__Eve2_396_0_19, 121, -1, -1, 0, 4, 1, 1, 0, 
"b - 'UChar_t' 0 - r b - 'UChar_t' 0 - g "
"b - 'UChar_t' 0 - b b - 'UChar_t' 0 '255' a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBackColor",1168,G__G__Eve2_396_0_20, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PtrBackColor",1190,G__G__Eve2_396_0_21, 83, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBackRGBA",941,G__G__Eve2_396_0_22, 66, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBackColor",1180,G__G__Eve2_396_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - ci", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBackColorPixel",1694,G__G__Eve2_396_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - pix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBackColorRGBA",1464,G__G__Eve2_396_0_25, 121, -1, -1, 0, 4, 1, 1, 0, 
"b - 'UChar_t' 0 - r b - 'UChar_t' 0 - g "
"b - 'UChar_t' 0 - b b - 'UChar_t' 0 '255' a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameFill",1170,G__G__Eve2_396_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameFill",1182,G__G__Eve2_396_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawBack",1055,G__G__Eve2_396_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawBack",1067,G__G__Eve2_396_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_396_0_30, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveFrameBox::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_396_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveFrameBox::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_396_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveFrameBox::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_396_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveFrameBox::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_396_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__Eve2_396_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveFrameBox::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_396_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveFrameBox::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_396_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveFrameBox::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_396_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveFrameBox::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveFrameBox", 1286, G__G__Eve2_396_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveFrameBoxGL(void) {
   /* TEveFrameBoxGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBoxGL));
   G__memfunc_setup("TEveFrameBoxGL",1307,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBoxGL), -1, 0, 0, 1, 4, 0, "", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveFrameBoxGL",1307,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBoxGL), -1, 0, 1, 1, 4, 0, "u 'TEveFrameBoxGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBoxGL), -1, 1, 1, 1, 4, 0, "u 'TEveFrameBoxGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("RenderFrame",1099,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 4, 0, 
"u 'TEveFrameBox' - 11 - b g - 'Bool_t' 0 - fillp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Render",608,G__G__Eve2_397_0_5, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TEveFrameBox' - 10 - box", (char*)NULL, (void*) G__func2void( (void (*)(const TEveFrameBox*))(&TEveFrameBoxGL::Render) ), 0);
   G__memfunc_setup("Class",502,G__G__Eve2_397_0_6, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveFrameBoxGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_397_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveFrameBoxGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_397_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveFrameBoxGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_397_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveFrameBoxGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve2_397_0_10, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve2_397_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__Eve2_397_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__Eve2_397_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__Eve2_397_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveFrameBoxGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_397_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveFrameBoxGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_397_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveFrameBoxGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_397_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveFrameBoxGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveFrameBoxGL", 1433, G__G__Eve2_397_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveRGBAPalette(void) {
   /* TEveRGBAPalette */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette));
   G__memfunc_setup("TEveRGBAPalette",1375,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette), -1, 0, 1, 1, 4, 0, "u 'TEveRGBAPalette' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette), -1, 1, 1, 1, 4, 0, "u 'TEveRGBAPalette' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("SetupColor",1040,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"i - 'Int_t' 0 - val B - 'UChar_t' 0 - pix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveRGBAPalette",1375,G__G__Eve2_399_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveRGBAPalette",1375,G__G__Eve2_399_0_5, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette), -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - min i - 'Int_t' 0 - max "
"g - 'Bool_t' 0 'kTRUE' interp g - 'Bool_t' 0 'kTRUE' showdef "
"g - 'Bool_t' 0 'kFALSE' fixcolrng", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetupColorArray",1551,G__G__Eve2_399_0_6, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearColorArray",1509,G__G__Eve2_399_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WithinVisibleRange",1838,G__G__Eve2_399_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColorFromValue",1424,G__G__Eve2_399_0_9, 66, -1, G__defined_typename("UChar_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColorFromValue",1424,G__G__Eve2_399_0_10, 121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - val B - 'UChar_t' 0 - pix "
"g - 'Bool_t' 0 'kTRUE' alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ColorFromValue",1424,G__G__Eve2_399_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 8, 
"i - 'Int_t' 0 - val i - 'Int_t' 0 - defVal "
"B - 'UChar_t' 0 - pix g - 'Bool_t' 0 'kTRUE' alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinVal",871,G__G__Eve2_399_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxVal",873,G__G__Eve2_399_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLimits",926,G__G__Eve2_399_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - low i - 'Int_t' 0 - high", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLimitsScaleMinMax",2000,G__G__Eve2_399_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - low i - 'Int_t' 0 - high", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinMax",886,G__G__Eve2_399_0_16, 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("SetMin",592,G__G__Eve2_399_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - min", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMax",594,G__G__Eve2_399_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLowLimit",1105,G__G__Eve2_399_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHighLimit",1183,G__G__Eve2_399_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInterpolate",1447,G__G__Eve2_399_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInterpolate",1459,G__G__Eve2_399_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShowDefValue",1485,G__G__Eve2_399_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShowDefValue",1497,G__G__Eve2_399_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFixColorRange",1587,G__G__Eve2_399_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFixColorRange",1599,G__G__Eve2_399_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUnderflowAction",1844,G__G__Eve2_399_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOverflowAction",1746,G__G__Eve2_399_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUnderflowAction",1856,G__G__Eve2_399_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOverflowAction",1758,G__G__Eve2_399_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultColor",1508,G__G__Eve2_399_0_31, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PtrDefaultColor",1530,G__G__Eve2_399_0_32, 83, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultRGBA",1281,G__G__Eve2_399_0_33, 66, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultRGBA",1281,G__G__Eve2_399_0_34, 66, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDefaultColor",1520,G__G__Eve2_399_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - ci", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDefaultColorPixel",2034,G__G__Eve2_399_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - pix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDefaultColorRGBA",1804,G__G__Eve2_399_0_37, 121, -1, -1, 0, 4, 1, 1, 0, 
"b - 'UChar_t' 0 - r b - 'UChar_t' 0 - g "
"b - 'UChar_t' 0 - b b - 'UChar_t' 0 '255' a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUnderColor",1309,G__G__Eve2_399_0_38, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PtrUnderColor",1331,G__G__Eve2_399_0_39, 83, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUnderRGBA",1082,G__G__Eve2_399_0_40, 66, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUnderRGBA",1082,G__G__Eve2_399_0_41, 66, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUnderColor",1321,G__G__Eve2_399_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - ci", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUnderColorPixel",1835,G__G__Eve2_399_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - pix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUnderColorRGBA",1605,G__G__Eve2_399_0_44, 121, -1, -1, 0, 4, 1, 1, 0, 
"b - 'UChar_t' 0 - r b - 'UChar_t' 0 - g "
"b - 'UChar_t' 0 - b b - 'UChar_t' 0 '255' a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOverColor",1211,G__G__Eve2_399_0_45, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PtrOverColor",1233,G__G__Eve2_399_0_46, 83, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOverRGBA",984,G__G__Eve2_399_0_47, 66, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOverRGBA",984,G__G__Eve2_399_0_48, 66, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOverColor",1223,G__G__Eve2_399_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - ci", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOverColorPixel",1737,G__G__Eve2_399_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - pix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOverColorRGBA",1507,G__G__Eve2_399_0_51, 121, -1, -1, 0, 4, 1, 1, 0, 
"b - 'UChar_t' 0 - r b - 'UChar_t' 0 - g "
"b - 'UChar_t' 0 - b b - 'UChar_t' 0 '255' a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MinMaxValChanged",1559,G__G__Eve2_399_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_399_0_53, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveRGBAPalette::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_399_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRGBAPalette::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_399_0_55, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveRGBAPalette::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_399_0_56, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveRGBAPalette::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_399_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve2_399_0_61, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRGBAPalette::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_399_0_62, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRGBAPalette::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_399_0_63, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRGBAPalette::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_399_0_64, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRGBAPalette::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveRGBAPalette", 1501, G__G__Eve2_399_0_65, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveRGBAPaletteEditor(void) {
   /* TEveRGBAPaletteEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteEditor));
   G__memfunc_setup("TEveRGBAPaletteEditor",1990,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteEditor), -1, 0, 1, 1, 4, 0, "u 'TEveRGBAPaletteEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteEditor), -1, 1, 1, 1, 4, 0, "u 'TEveRGBAPaletteEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveRGBAPaletteEditor",1990,G__G__Eve2_400_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteEditor), -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__Eve2_400_0_5, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveRGBAPaletteEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_400_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRGBAPaletteEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_400_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveRGBAPaletteEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_400_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveRGBAPaletteEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_400_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__Eve2_400_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRGBAPaletteEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_400_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRGBAPaletteEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_400_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRGBAPaletteEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_400_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRGBAPaletteEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveRGBAPaletteEditor", 2116, G__G__Eve2_400_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveRGBAPaletteSubEditor(void) {
   /* TEveRGBAPaletteSubEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteSubEditor));
   G__memfunc_setup("TEveRGBAPaletteSubEditor",2288,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteSubEditor), -1, 0, 1, 1, 4, 0, "u 'TEveRGBAPaletteSubEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteSubEditor), -1, 1, 1, 1, 4, 0, "u 'TEveRGBAPaletteSubEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveRGBAPaletteSubEditor",2288,G__G__Eve2_401_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPaletteSubEditor), -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 10 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,G__G__Eve2_401_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveRGBAPalette' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Changed",682,G__G__Eve2_401_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("DoMinMax",765,G__G__Eve2_401_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoInterpolate",1338,G__G__Eve2_401_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoShowDefValue",1376,G__G__Eve2_401_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDefaultColor",1399,G__G__Eve2_401_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoFixColorRange",1478,G__G__Eve2_401_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoUnderColor",1200,G__G__Eve2_401_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoOverColor",1102,G__G__Eve2_401_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoUnderflowAction",1735,G__G__Eve2_401_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoOverflowAction",1637,G__G__Eve2_401_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_401_0_15, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveRGBAPaletteSubEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_401_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRGBAPaletteSubEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_401_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveRGBAPaletteSubEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_401_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveRGBAPaletteSubEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_401_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__Eve2_401_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRGBAPaletteSubEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_401_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRGBAPaletteSubEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_401_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveRGBAPaletteSubEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_401_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveRGBAPaletteSubEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveRGBAPaletteSubEditor", 2414, G__G__Eve2_401_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveDigitSet(void) {
   /* TEveDigitSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSet));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSet), -1, 1, 1, 1, 4, 0, "u 'TEveDigitSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("NewDigit",795,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetcLcLDigitBase_t), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReleaseIds",993,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObject",887,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TObject), -1, 0, 1, 1, 1, 8, "u 'TEveException' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UseSingleColor",1422,G__G__Eve2_419_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAntiFlick",1173,G__G__Eve2_419_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAntiFlick",1185,G__G__Eve2_419_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - f", (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("UnSelected",1004,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnHighlighted",1316,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHighlightTooltip",1955,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Eve2LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RefitPlex",915,G__G__Eve2_419_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ScanMinMaxValues",1599,G__G__Eve2_419_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 1 - min i - 'Int_t' 1 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentDigit",1536,G__G__Eve2_419_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DigitValue",1006,G__G__Eve2_419_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DigitColor",1008,G__G__Eve2_419_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - ci", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DigitColor",1008,G__G__Eve2_419_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 - ci c - 'Char_t' 0 - transparency", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DigitColor",1008,G__G__Eve2_419_0_20, 121, -1, -1, 0, 4, 1, 1, 0, 
"b - 'UChar_t' 0 - r b - 'UChar_t' 0 - g "
"b - 'UChar_t' 0 - b b - 'UChar_t' 0 '255' a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DigitColor",1008,G__G__Eve2_419_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "B - 'UChar_t' 0 - rgba", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOwnIds",884,G__G__Eve2_419_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOwnIds",896,G__G__Eve2_419_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - o", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DigitId",670,G__G__Eve2_419_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DigitUserData",1290,G__G__Eve2_419_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - ud", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DigitId",670,G__G__Eve2_419_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n U 'TObject' - 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DigitUserData",1290,G__G__Eve2_419_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n Y - - 0 - ud", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDigit",785,G__G__Eve2_419_0_28, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetcLcLDigitBase_t), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetId",461,G__G__Eve2_419_0_29, 85, G__get_linked_tagnum(&G__G__Eve2LN_TObject), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUserData",1081,G__G__Eve2_419_0_30, 89, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - n", (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("DigitSelected",1306,G__G__Eve2_419_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SecSelected",1092,G__G__Eve2_419_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveDigitSet' - 0 - qs i - 'Int_t' 0 - idx", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("GetPlex",697,G__G__Eve2_419_0_34, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveChunkManager), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrame",779,G__G__Eve2_419_0_35, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveFrameBox), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrame",791,G__G__Eve2_419_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveFrameBox' - 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValueIsColor",1496,G__G__Eve2_419_0_37, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPalette",1007,G__G__Eve2_419_0_38, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPalette",1019,G__G__Eve2_419_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveRGBAPalette' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AssertPalette",1345,G__G__Eve2_419_0_40, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRenderMode",1285,G__G__Eve2_419_0_41, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetcLcLERenderMode_e), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRenderMode",1297,G__G__Eve2_419_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TEveDigitSet::ERenderMode_e' - 0 - rm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDisableLighting",1802,G__G__Eve2_419_0_43, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDisableLighting",1814,G__G__Eve2_419_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistoButtons",1558,G__G__Eve2_419_0_45, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHistoButtons",1570,G__G__Eve2_419_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEmitSignals",1408,G__G__Eve2_419_0_47, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEmitSignals",1420,G__G__Eve2_419_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCallbackFoo",1361,G__G__Eve2_419_0_49, 89, -1, G__defined_typename("TEveDigitSet::Callback_foo"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCallbackFoo",1373,G__G__Eve2_419_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "Y - 'TEveDigitSet::Callback_foo' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTooltipCBFoo",1460,G__G__Eve2_419_0_51, 89, -1, G__defined_typename("TEveDigitSet::TooltipCB_foo"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTooltipCBFoo",1472,G__G__Eve2_419_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "Y - 'TEveDigitSet::TooltipCB_foo' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_419_0_53, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveDigitSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_419_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveDigitSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_419_0_55, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveDigitSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_419_0_56, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveDigitSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_419_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve2_419_0_61, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveDigitSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_419_0_62, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveDigitSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_419_0_63, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveDigitSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_419_0_64, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveDigitSet::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveDigitSet", 1295, G__G__Eve2_419_0_65, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveDigitSetEditor(void) {
   /* TEveDigitSetEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetEditor));
   G__memfunc_setup("TEveDigitSetEditor",1784,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetEditor), -1, 0, 1, 1, 4, 0, "u 'TEveDigitSetEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetEditor), -1, 1, 1, 1, 4, 0, "u 'TEveDigitSetEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("CreateInfoTab",1271,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveDigitSetEditor",1784,G__G__Eve2_420_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetEditor), -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("DoHisto",698,G__G__Eve2_420_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRangeHisto",1191,G__G__Eve2_420_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PlotHisto",934,G__G__Eve2_420_0_8, 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("Class",502,G__G__Eve2_420_0_9, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveDigitSetEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_420_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveDigitSetEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_420_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveDigitSetEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_420_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveDigitSetEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_420_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__Eve2_420_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveDigitSetEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_420_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveDigitSetEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_420_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveDigitSetEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_420_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveDigitSetEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveDigitSetEditor", 1910, G__G__Eve2_420_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveDigitSetGL(void) {
   /* TEveDigitSetGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetGL));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveDigitSetGL), -1, 1, 1, 1, 4, 0, "u 'TEveDigitSetGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("SetupColor",1040,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 8, "u 'TEveDigitSet::DigitBase_t' - 11 - q", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBBox",663,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawHighlight",1318,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"u 'TGLRnrCtx' - 1 - rnrCtx U 'TGLPhysicalShape' - 10 - pshp "
"i - 'Int_t' 0 '-1' lvl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SupportsSecondarySelect",2424,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AlwaysSecondarySelect",2169,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessSelection",1669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'TGLSelectRecord' - 1 - rec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_421_0_10, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveDigitSetGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_421_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveDigitSetGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_421_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveDigitSetGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_421_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveDigitSetGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_421_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__Eve2_421_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveDigitSetGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_421_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveDigitSetGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_421_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveDigitSetGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_421_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveDigitSetGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveDigitSetGL", 1442, G__G__Eve2_421_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveBoxSet(void) {
   /* TEveBoxSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSet));
   G__memfunc_setup("TEveBoxSet",969,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSet), -1, 0, 1, 1, 4, 0, "u 'TEveBoxSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSet), -1, 1, 1, 1, 4, 0, "u 'TEveBoxSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("SizeofAtom",1025,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 2, 0, "i 'TEveBoxSet::EBoxType_e' - 0 - bt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveBoxSet",969,G__G__Eve2_425_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSet), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEveBoxSet\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Eve2_425_0_5, 121, -1, -1, 0, 3, 1, 1, 0, 
"i 'TEveBoxSet::EBoxType_e' - 0 - boxType g - 'Bool_t' 0 - valIsCol "
"i - 'Int_t' 0 - chunkSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Eve2_425_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBox",562,G__G__Eve2_425_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - verts", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBox",562,G__G__Eve2_425_0_8, 121, -1, -1, 0, 6, 1, 1, 0, 
"f - 'Float_t' 0 - a f - 'Float_t' 0 - b "
"f - 'Float_t' 0 - c f - 'Float_t' 0 - w "
"f - 'Float_t' 0 - h f - 'Float_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBox",562,G__G__Eve2_425_0_9, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - a f - 'Float_t' 0 - b "
"f - 'Float_t' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddCone",654,G__G__Eve2_425_0_10, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TEveVectorT<float>' 'TEveVector' 11 - pos u 'TEveVectorT<float>' 'TEveVector' 11 - dir "
"f - 'Float_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddEllipticCone",1476,G__G__Eve2_425_0_11, 121, -1, -1, 0, 5, 1, 1, 0, 
"u 'TEveVectorT<float>' 'TEveVector' 11 - pos u 'TEveVectorT<float>' 'TEveVector' 11 - dir "
"f - 'Float_t' 0 - r f - 'Float_t' 0 - r2 "
"f - 'Float_t' 0 '0' angle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Test",416,G__G__Eve2_425_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nboxes", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefWidth",1071,G__G__Eve2_425_0_14, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefHeight",1160,G__G__Eve2_425_0_15, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefDepth",1060,G__G__Eve2_425_0_16, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawConeCap",1351,G__G__Eve2_425_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDefWidth",1083,G__G__Eve2_425_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDefHeight",1172,G__G__Eve2_425_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDefDepth",1072,G__G__Eve2_425_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawConeCap",1363,G__G__Eve2_425_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_425_0_22, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveBoxSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_425_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBoxSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_425_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveBoxSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_425_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveBoxSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_425_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve2_425_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBoxSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_425_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveBoxSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_425_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBoxSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_425_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveBoxSet::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveBoxSet", 1095, G__G__Eve2_425_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveBoxSetGL(void) {
   /* TEveBoxSetGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSetGL));
   G__memfunc_setup("TEveBoxSetGL",1116,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSetGL), -1, 0, 1, 1, 4, 0, "u 'TEveBoxSetGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSetGL), -1, 1, 1, 1, 4, 0, "u 'TEveBoxSetGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("PrimitiveType",1371,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeOriginBox",1295,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 8, 
"f - 'Float_t' 0 - p[][3] f - 'Float_t' 0 - dx "
"f - 'Float_t' 0 - dy f - 'Float_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderBoxStdNorm",1616,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "f - 'Float_t' 10 - p[][3]", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderBoxAutoNorm",1726,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "f - 'Float_t' 10 - p[][3]", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeDisplayList",1520,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderBoxes",1121,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveBoxSetGL",1116,G__G__Eve2_426_0_9, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveBoxSetGL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShouldDLCache",1235,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 11 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DLCacheDrop",1017,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DLCachePurge",1127,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   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("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("Render",608,G__G__Eve2_426_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_426_0_16, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveBoxSetGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_426_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBoxSetGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_426_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveBoxSetGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_426_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveBoxSetGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_426_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__Eve2_426_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBoxSetGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_426_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveBoxSetGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_426_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveBoxSetGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_426_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveBoxSetGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveBoxSetGL", 1242, G__G__Eve2_426_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCaloData(void) {
   /* TEveCaloData */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData), -1, 1, 1, 1, 4, 0, "u 'TEveCaloData' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("UnSelected",1004,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnHighlighted",1316,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHighlightTooltip",1955,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Eve2LN_TString), -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("GetCellList",1084,G__G__Eve2_436_0_8, 121, -1, -1, 0, 5, 1, 1, 8, 
"f - 'Float_t' 0 - etaMin f - 'Float_t' 0 - etaMax "
"f - 'Float_t' 0 - phi f - 'Float_t' 0 - phiRng "
"u 'vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >' 'TEveCaloData::vCellId_t' 1 - out", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetCellsSelected",1596,G__G__Eve2_436_0_9, 117, G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgR), G__defined_typename("TEveCaloData::vCellId_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCellsHighlighted",1908,G__G__Eve2_436_0_10, 117, G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgR), G__defined_typename("TEveCaloData::vCellId_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintCellsSelected",1833,G__G__Eve2_436_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessSelection",1669,G__G__Eve2_436_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >' 'TEveCaloData::vCellId_t' 1 - sel_cells u 'TGLSelectRecord' - 1 - rec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rebin",496,G__G__Eve2_436_0_13, 121, -1, -1, 0, 5, 1, 1, 8, 
"U 'TAxis' - 0 - ax U 'TAxis' - 0 - ay "
"u 'vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >' 'TEveCaloData::vCellId_t' 1 - in g - 'Bool_t' 0 - et "
"u 'TEveCaloData::RebinData_t' - 1 - out", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetCellData",1050,G__G__Eve2_436_0_14, 121, -1, -1, 0, 2, 1, 1, 8, 
"u 'TEveCaloData::CellId_t' - 11 - id u 'TEveCaloData::CellData_t' - 1 - data", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("InvalidateUsersCellIdCache",2580,G__G__Eve2_436_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataChanged",1060,G__G__Eve2_436_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CellSelectionChanged",2000,G__G__Eve2_436_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNSlices",977,G__G__Eve2_436_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefSliceInfo",1177,G__G__Eve2_436_0_19, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDatacLcLSliceInfo_t), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSliceThreshold",1737,G__G__Eve2_436_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - slice f - 'Float_t' 0 - threshold", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSliceThreshold",1725,G__G__Eve2_436_0_21, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - slice", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSliceColor",1307,G__G__Eve2_436_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - slice s - 'Color_t' 0 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSliceColor",1295,G__G__Eve2_436_0_23, 115, -1, G__defined_typename("Color_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - slice", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSliceTransparency",2070,G__G__Eve2_436_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - slice c - 'Char_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSliceTransparency",2058,G__G__Eve2_436_0_25, 99, -1, G__defined_typename("Char_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - slice", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEtaLimits",1196,G__G__Eve2_436_0_26, 121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - min d - 'Double_t' 1 - max", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPhiLimits",1203,G__G__Eve2_436_0_27, 121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - min d - 'Double_t' 1 - max", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMaxVal",873,G__G__Eve2_436_0_28, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "g - 'Bool_t' 0 - et", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Empty",527,G__G__Eve2_436_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEtaBins",966,G__G__Eve2_436_0_30, 85, G__get_linked_tagnum(&G__G__Eve2LN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEtaBins",978,G__G__Eve2_436_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TAxis' - 0 - ax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPhiBins",973,G__G__Eve2_436_0_32, 85, G__get_linked_tagnum(&G__G__Eve2LN_TAxis), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPhiBins",985,G__G__Eve2_436_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TAxis' - 0 - ax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEps",584,G__G__Eve2_436_0_34, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEps",596,G__G__Eve2_436_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - eps", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetWrapTwoPi",1197,G__G__Eve2_436_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWrapTwoPi",1209,G__G__Eve2_436_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EtaToTheta",979,G__G__Eve2_436_0_38, 102, -1, G__defined_typename("Float_t"), 0, 1, 3, 1, 0, "f - 'Float_t' 0 - eta", (char*)NULL, (void*) G__func2void( (Float_t (*)(Float_t))(&TEveCaloData::EtaToTheta) ), 0);
   G__memfunc_setup("Class",502,G__G__Eve2_436_0_39, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCaloData::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_436_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloData::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_436_0_41, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCaloData::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_436_0_42, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCaloData::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_436_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__Eve2_436_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloData::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_436_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloData::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_436_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloData::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_436_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloData::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCaloData", 1259, G__G__Eve2_436_0_51, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCaloDatacLcLSliceInfo_t(void) {
   /* TEveCaloData::SliceInfo_t */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDatacLcLSliceInfo_t));
   G__memfunc_setup("SliceInfo_t",1103,G__G__Eve2_437_0_1, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDatacLcLSliceInfo_t), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Setup",529,G__G__Eve2_437_0_2, 121, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 - name f - 'Float_t' 0 - threshold "
"s - 'Color_t' 0 - col c - 'Char_t' 0 '101' transp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_437_0_3, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCaloData::SliceInfo_t::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_437_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloData::SliceInfo_t::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_437_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCaloData::SliceInfo_t::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_437_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCaloData::SliceInfo_t::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve2_437_0_7, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve2_437_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__Eve2_437_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__Eve2_437_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__Eve2_437_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloData::SliceInfo_t::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_437_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloData::SliceInfo_t::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_437_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloData::SliceInfo_t::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_437_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloData::SliceInfo_t::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("SliceInfo_t", 1103, G__G__Eve2_437_0_15, (int) ('i'), G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDatacLcLSliceInfo_t), -1, 0, 1, 1, 1, 0, "u 'TEveCaloData::SliceInfo_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~SliceInfo_t", 1229, G__G__Eve2_437_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__Eve2_437_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDatacLcLSliceInfo_t), -1, 1, 1, 1, 1, 0, "u 'TEveCaloData::SliceInfo_t' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCaloDataVec(void) {
   /* TEveCaloDataVec */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataVec));
   G__memfunc_setup("TEveCaloDataVec",1419,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataVec), -1, 0, 1, 1, 4, 0, "u 'TEveCaloDataVec' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataVec), -1, 1, 1, 1, 4, 0, "u 'TEveCaloDataVec' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveCaloDataVec",1419,G__G__Eve2_461_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataVec), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nslices", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSlice",761,G__G__Eve2_461_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTower",794,G__G__Eve2_461_0_5, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"f - 'Float_t' 0 - etaMin f - 'Float_t' 0 - etaMax "
"f - 'Float_t' 0 - phiMin f - 'Float_t' 0 - phiMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillSlice",887,G__G__Eve2_461_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - slice f - 'Float_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillSlice",887,G__G__Eve2_461_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - slice i - 'Int_t' 0 - tower "
"f - 'Float_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNCells",865,G__G__Eve2_461_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSliceVals",1190,G__G__Eve2_461_0_9, 117, G__get_linked_tagnum(&G__G__Eve2LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - slice", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCellGeom",1064,G__G__Eve2_461_0_10, 117, G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgR), G__defined_typename("vector<TEveCaloData::CellGeom_t>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCellList",1084,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 8, 
"f - 'Float_t' 0 - etaMin f - 'Float_t' 0 - etaMax "
"f - 'Float_t' 0 - phi f - 'Float_t' 0 - phiRng "
"u 'vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >' 'TEveCaloData::vCellId_t' 1 - out", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rebin",496,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 8, 
"U 'TAxis' - 0 - ax U 'TAxis' - 0 - ay "
"u 'vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >' 'TEveCaloData::vCellId_t' 1 - in g - 'Bool_t' 0 - et "
"u 'TEveCaloData::RebinData_t' - 1 - out", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCellData",1050,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"u 'TEveCaloData::CellId_t' - 11 - id u 'TEveCaloData::CellData_t' - 1 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEtaLimits",1196,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - min d - 'Double_t' 1 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPhiLimits",1203,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - min d - 'Double_t' 1 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataChanged",1060,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAxisFromBins",1505,G__G__Eve2_461_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '0.001' epsX d - 'Double_t' 0 '0.001' epsY", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_461_0_18, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCaloDataVec::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_461_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloDataVec::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_461_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCaloDataVec::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_461_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCaloDataVec::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_461_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__Eve2_461_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloDataVec::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_461_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloDataVec::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_461_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloDataVec::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_461_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloDataVec::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCaloDataVec", 1545, G__G__Eve2_461_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCaloDataHist(void) {
   /* TEveCaloDataHist */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataHist));
   G__memfunc_setup("TEveCaloDataHist",1541,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataHist), -1, 0, 1, 1, 4, 0, "u 'TEveCaloDataHist' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataHist), -1, 1, 1, 1, 4, 0, "u 'TEveCaloDataHist' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveCaloDataHist",1541,G__G__Eve2_466_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloDataHist), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCellList",1084,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 8, 
"f - 'Float_t' 0 - etaMin f - 'Float_t' 0 - etaMax "
"f - 'Float_t' 0 - phi f - 'Float_t' 0 - phiRng "
"u 'vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >' 'TEveCaloData::vCellId_t' 1 - out", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Rebin",496,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 8, 
"U 'TAxis' - 0 - ax U 'TAxis' - 0 - ay "
"u 'vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >' 'TEveCaloData::vCellId_t' 1 - in g - 'Bool_t' 0 - et "
"u 'TEveCaloData::RebinData_t' - 1 - out", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCellData",1050,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"u 'TEveCaloData::CellId_t' - 11 - id u 'TEveCaloData::CellData_t' - 1 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEtaLimits",1196,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - min d - 'Double_t' 1 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPhiLimits",1203,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - min d - 'Double_t' 1 - max", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataChanged",1060,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStack",790,G__G__Eve2_466_0_10, 85, G__get_linked_tagnum(&G__G__Eve2LN_THStack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHist",696,G__G__Eve2_466_0_11, 85, G__get_linked_tagnum(&G__G__Eve2LN_TH2F), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - slice", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHistogram",1207,G__G__Eve2_466_0_12, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TH2F' - 0 - hist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_466_0_13, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCaloDataHist::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_466_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloDataHist::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_466_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCaloDataHist::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_466_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCaloDataHist::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_466_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__Eve2_466_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloDataHist::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_466_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloDataHist::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_466_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloDataHist::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_466_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloDataHist::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCaloDataHist", 1667, G__G__Eve2_466_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCaloViz(void) {
   /* TEveCaloViz */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloViz));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloViz), -1, 1, 1, 1, 4, 0, "u 'TEveCaloViz' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("AssignCaloVizParameters",2353,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TEveCaloViz' - 0 - cv", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetupColorHeight",1641,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 8, 
"f - 'Float_t' 0 - value i - 'Int_t' 0 - slice "
"f - 'Float_t' 1 - height", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildCellIdCache",1521,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ForwardSelection",1659,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ForwardEdit",1115,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (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("ProjectedClass",1430,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 1, 1, 1, 8, "U 'TEveProjection' - 10 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValToHeight",1375,G__G__Eve2_478_0_11, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CellSelectionChanged",2000,G__G__Eve2_478_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetScaleAbs",1066,G__G__Eve2_478_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetData",666,G__G__Eve2_478_0_14, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloData), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetData",678,G__G__Eve2_478_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveCaloData' - 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DataChanged",1060,G__G__Eve2_478_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxVal",873,G__G__Eve2_478_0_17, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AssertCellIdCache",1651,G__G__Eve2_478_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InvalidateCellIdCache",2050,G__G__Eve2_478_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataSliceThreshold",2103,G__G__Eve2_478_0_20, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - slice", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDataSliceThreshold",2115,G__G__Eve2_478_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - slice f - 'Float_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataSliceColor",1673,G__G__Eve2_478_0_22, 115, -1, G__defined_typename("Color_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - slice", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDataSliceColor",1685,G__G__Eve2_478_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - slice s - 'Color_t' 0 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBarrelRadius",1504,G__G__Eve2_478_0_24, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBarrelRadius",1516,G__G__Eve2_478_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEndCapPos",1149,G__G__Eve2_478_0_26, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEndCapPos",1161,G__G__Eve2_478_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlotEt",888,G__G__Eve2_478_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPlotEt",900,G__G__Eve2_478_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxTowerH",1195,G__G__Eve2_478_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxTowerH",1183,G__G__Eve2_478_0_31, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScaleAbs",1054,G__G__Eve2_478_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxValAbs",1163,G__G__Eve2_478_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxValAbs",1151,G__G__Eve2_478_0_34, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTransitionEta",1637,G__G__Eve2_478_0_35, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTransitionTheta",1857,G__G__Eve2_478_0_36, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPalette",1007,G__G__Eve2_478_0_37, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPalette",1019,G__G__Eve2_478_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveRGBAPalette' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AssertPalette",1345,G__G__Eve2_478_0_39, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveRGBAPalette), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValueIsColor",1496,G__G__Eve2_478_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValueIsColor",1508,G__G__Eve2_478_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAutoRange",1190,G__G__Eve2_478_0_42, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAutoRange",1202,G__G__Eve2_478_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEta",582,G__G__Eve2_478_0_44, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - l f - 'Float_t' 0 - u", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEta",570,G__G__Eve2_478_0_45, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEtaMin",862,G__G__Eve2_478_0_46, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEtaMax",864,G__G__Eve2_478_0_47, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEtaRng",865,G__G__Eve2_478_0_48, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPhi",589,G__G__Eve2_478_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPhiRng",884,G__G__Eve2_478_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - rng", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPhiWithRng",1296,G__G__Eve2_478_0_51, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - x f - 'Float_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhi",577,G__G__Eve2_478_0_52, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhiMin",869,G__G__Eve2_478_0_53, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhiMax",871,G__G__Eve2_478_0_54, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhiRng",872,G__G__Eve2_478_0_55, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CellInEtaPhiRng",1433,G__G__Eve2_478_0_56, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TEveCaloData::CellData_t' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_478_0_57, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCaloViz::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_478_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloViz::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_478_0_59, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCaloViz::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_478_0_60, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCaloViz::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_478_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve2_478_0_65, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloViz::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_478_0_66, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloViz::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_478_0_67, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloViz::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_478_0_68, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloViz::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCaloViz", 1194, G__G__Eve2_478_0_69, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCaloVizEditor(void) {
   /* TEveCaloVizEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloVizEditor));
   G__memfunc_setup("TEveCaloVizEditor",1683,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloVizEditor), -1, 0, 1, 1, 4, 0, "u 'TEveCaloVizEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloVizEditor), -1, 1, 1, 1, 4, 0, "u 'TEveCaloVizEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("MakeSliceInfo",1274,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveCaloVizEditor",1683,G__G__Eve2_479_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloVizEditor), -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("DoMaxTowerH",1074,G__G__Eve2_479_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoScaleAbs",945,G__G__Eve2_479_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoMaxValAbs",1042,G__G__Eve2_479_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPlot",594,G__G__Eve2_479_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoEtaRange",954,G__G__Eve2_479_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPhi",468,G__G__Eve2_479_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSliceThreshold",1616,G__G__Eve2_479_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSliceColor",1186,G__G__Eve2_479_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSliceTransparency",1949,G__G__Eve2_479_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - transp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_479_0_15, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCaloVizEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_479_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloVizEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_479_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCaloVizEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_479_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCaloVizEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_479_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__Eve2_479_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloVizEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_479_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloVizEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_479_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloVizEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_479_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloVizEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCaloVizEditor", 1809, G__G__Eve2_479_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCalo3D(void) {
   /* TEveCalo3D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3D));
   G__memfunc_setup("TEveCalo3D",874,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3D), -1, 0, 1, 1, 4, 0, "u 'TEveCalo3D' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3D), -1, 1, 1, 1, 4, 0, "u 'TEveCalo3D' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("BuildCellIdCache",1521,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TEveCalo3D",874,G__G__Eve2_480_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3D), -1, 0, 3, 1, 1, 0, 
"U 'TEveCaloData' - 0 '0' d C - - 10 '\"TEveCalo3D\"' n "
"C - - 10 '\"xx\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFrameWidth",1303,G__G__Eve2_480_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameWidth",1291,G__G__Eve2_480_0_7, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRnrFrame",1097,G__G__Eve2_480_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - e g - 'Bool_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRnrFrame",1085,G__G__Eve2_480_0_9, 121, -1, -1, 0, 2, 1, 1, 8, 
"g - 'Bool_t' 1 - e g - 'Bool_t' 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRnrEndCapFrame",1652,G__G__Eve2_480_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRnrBarrelFrame",1697,G__G__Eve2_480_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRnrEndCapFrame",1640,G__G__Eve2_480_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRnrBarrelFrame",1685,G__G__Eve2_480_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameTransparency",2065,G__G__Eve2_480_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrameTransparency",2053,G__G__Eve2_480_0_15, 99, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_480_0_16, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCalo3D::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_480_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCalo3D::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_480_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCalo3D::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_480_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCalo3D::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_480_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__Eve2_480_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCalo3D::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_480_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCalo3D::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_480_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCalo3D::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_480_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCalo3D::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCalo3D", 1000, G__G__Eve2_480_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCalo3DGL(void) {
   /* TEveCalo3DGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DGL));
   G__memfunc_setup("TEveCalo3DGL",1021,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DGL), -1, 0, 1, 1, 4, 0, "u 'TEveCalo3DGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DGL), -1, 1, 1, 1, 4, 0, "u 'TEveCalo3DGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("CrossProduct",1259,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 8, 
"F - 'Float_t' 10 - a F - 'Float_t' 10 - b "
"F - 'Float_t' 10 - c F - 'Float_t' 0 - out", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderBox",905,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "F - 'Float_t' 10 - pnts", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderGridEndCap",1553,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderGridBarrel",1598,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderGrid",998,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderBarrelCell",1592,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"u 'TEveCaloData::CellGeom_t' - 11 - cell f - 'Float_t' 0 - towerH "
"f - 'Float_t' 1 - offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderEndCapCell",1547,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"u 'TEveCaloData::CellGeom_t' - 11 - cell f - 'Float_t' 0 - towerH "
"f - 'Float_t' 1 - offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawSelectedCells",1706,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >' 'TEveCaloData::vCellId_t' 0 - cells", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveCalo3DGL",1021,G__G__Eve2_481_0_11, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DGL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBBox",663,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawHighlight",1318,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"u 'TGLRnrCtx' - 1 - rnrCtx U 'TGLPhysicalShape' - 10 - ps "
"i - 'Int_t' 0 '-1' lvl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShouldDLCache",1235,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 11 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SupportsSecondarySelect",2424,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AlwaysSecondarySelect",2169,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessSelection",1669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'TGLSelectRecord' - 1 - rec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_481_0_20, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCalo3DGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_481_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCalo3DGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_481_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCalo3DGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_481_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCalo3DGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_481_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__Eve2_481_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCalo3DGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_481_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCalo3DGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_481_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCalo3DGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_481_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCalo3DGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCalo3DGL", 1147, G__G__Eve2_481_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCalo2D(void) {
   /* TEveCalo2D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D));
   G__memfunc_setup("TEveCalo2D",873,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D), -1, 0, 1, 1, 4, 0, "u 'TEveCalo2D' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D), -1, 1, 1, 1, 4, 0, "u 'TEveCalo2D' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("CellSelectionChangedInternal",2829,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >' 'TEveCaloData::vCellId_t' 1 - cells u 'vector<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >*,allocator<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >*> >' 'vector<TEveCaloData::vCellId_t*>' 1 - cellLists", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildCellIdCache",1521,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDepthLocal",1292,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TEveCalo2D",873,G__G__Eve2_482_0_6, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2D), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEveCalo2D\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProjection",1353,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveProjectionManager' - 0 - proj U 'TEveProjectable' - 0 - model", (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("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CellSelectionChanged",2000,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetScaleAbs",1066,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetValToHeight",1375,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_482_0_13, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCalo2D::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_482_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCalo2D::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_482_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCalo2D::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_482_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCalo2D::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_482_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__Eve2_482_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCalo2D::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_482_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCalo2D::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_482_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCalo2D::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_482_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCalo2D::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCalo2D", 999, G__G__Eve2_482_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCalo2DGL(void) {
   /* TEveCalo2DGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2DGL));
   G__memfunc_setup("TEveCalo2DGL",1020,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2DGL), -1, 0, 1, 1, 4, 0, "u 'TEveCalo2DGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2DGL), -1, 1, 1, 1, 4, 0, "u 'TEveCalo2DGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("MakeRhoZCell",1153,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 2, 8, 
"f - 'Float_t' 0 - thetaMin f - 'Float_t' 0 - thetaMax "
"f - 'Float_t' 1 - offset g - 'Bool_t' 0 - isBarrel "
"g - 'Bool_t' 0 - phiPlus f - 'Float_t' 0 - towerH", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeRPhiCell",1137,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 8, 
"f - 'Float_t' 0 - phiMin f - 'Float_t' 0 - phiMax "
"f - 'Float_t' 0 - towerH f - 'Float_t' 0 - offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawRPhi",769,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'vector<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >*,allocator<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >*> >' 'TEveCalo2D::vBinCells_t' 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawRPhiHighlighted",1890,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "u 'vector<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >*,allocator<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >*> >' 'vector<TEveCaloData::vCellId_t*>' 1 - cellLists", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawRhoZ",785,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'vector<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >*,allocator<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >*> >' 'TEveCalo2D::vBinCells_t' 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawRhoZHighlighted",1906,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "u 'vector<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >*,allocator<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >*> >' 'vector<TEveCaloData::vCellId_t*>' 1 - cellLists", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRPhi",559,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveCalo2DGL",1020,G__G__Eve2_483_0_10, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo2DGL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBBox",663,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawHighlight",1318,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"u 'TGLRnrCtx' - 1 - rnrCtx U 'TGLPhysicalShape' - 10 - ps "
"i - 'Int_t' 0 '-1' lvl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SupportsSecondarySelect",2424,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AlwaysSecondarySelect",2169,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessSelection",1669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'TGLSelectRecord' - 1 - rec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_483_0_18, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCalo2DGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_483_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCalo2DGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_483_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCalo2DGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_483_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCalo2DGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_483_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__Eve2_483_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCalo2DGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_483_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCalo2DGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_483_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCalo2DGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_483_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCalo2DGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCalo2DGL", 1146, G__G__Eve2_483_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCaloLego(void) {
   /* TEveCaloLego */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego));
   G__memfunc_setup("TEveCaloLego",1146,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego), -1, 0, 1, 1, 4, 0, "u 'TEveCaloLego' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego), -1, 1, 1, 1, 4, 0, "u 'TEveCaloLego' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("BuildCellIdCache",1521,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TEveCaloLego",1146,G__G__Eve2_488_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego), -1, 0, 3, 1, 1, 0, 
"U 'TEveCaloData' - 0 '0' data C - - 10 '\"TEveCaloLego\"' n "
"C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetData",678,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveCaloData' - 0 - d", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFontColor",1206,G__G__Eve2_488_0_7, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFontColor",1218,G__G__Eve2_488_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - ci", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGridColor",1189,G__G__Eve2_488_0_9, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGridColor",1201,G__G__Eve2_488_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - ci", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlaneColor",1295,G__G__Eve2_488_0_11, 115, -1, G__defined_typename("Color_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPlaneColor",1307,G__G__Eve2_488_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - ci", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlaneTransparency",2058,G__G__Eve2_488_0_13, 99, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPlaneTransparency",2070,G__G__Eve2_488_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNZSteps",983,G__G__Eve2_488_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNZSteps",995,G__G__Eve2_488_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPixelsPerBin",1493,G__G__Eve2_488_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPixelsPerBin",1505,G__G__Eve2_488_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - bw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAutoRebin",1193,G__G__Eve2_488_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAutoRebin",1205,G__G__Eve2_488_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNormalizeRebin",1729,G__G__Eve2_488_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNormalizeRebin",1741,G__G__Eve2_488_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProjection",1341,G__G__Eve2_488_0_23, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegocLcLEProjection_e), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProjection",1353,G__G__Eve2_488_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TEveCaloLego::EProjection_e' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Set2DMode",807,G__G__Eve2_488_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TEveCaloLego::E2DMode_e' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Get2DMode",795,G__G__Eve2_488_0_26, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegocLcLE2DMode_e), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHasFixedHeightIn2DMode",2359,G__G__Eve2_488_0_27, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHasFixedHeightIn2DMode",2371,G__G__Eve2_488_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFixedHeightValIn2DMode",2366,G__G__Eve2_488_0_29, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFixedHeightValIn2DMode",2378,G__G__Eve2_488_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBoxMode",986,G__G__Eve2_488_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TEveCaloLego::EBoxMode_e' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBoxMode",974,G__G__Eve2_488_0_32, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegocLcLEBoxMode_e), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawHPlane",1254,G__G__Eve2_488_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawHPlane",1266,G__G__Eve2_488_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHPlaneVal",1147,G__G__Eve2_488_0_35, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHPlaneVal",1159,G__G__Eve2_488_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDrawNumberCellPixels",2316,G__G__Eve2_488_0_37, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawNumberCellPixels",2328,G__G__Eve2_488_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCellPixelFontSize",2004,G__G__Eve2_488_0_39, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCellPixelFontSize",2016,G__G__Eve2_488_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_488_0_41, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCaloLego::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_488_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloLego::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_488_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCaloLego::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_488_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCaloLego::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_488_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__Eve2_488_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloLego::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_488_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloLego::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_488_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloLego::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_488_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloLego::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCaloLego", 1272, G__G__Eve2_488_0_53, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCaloLegoGL(void) {
   /* TEveCaloLegoGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoGL));
   G__memfunc_setup("TEveCaloLegoGL",1293,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoGL), -1, 0, 1, 1, 4, 0, "u 'TEveCaloLegoGL' - 11 - -", "Stop default", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoGL), -1, 1, 1, 1, 4, 0, "u 'TEveCaloLegoGL' - 11 - -", "Stop default", (void*) NULL, 0);
   G__memfunc_setup("GetScaleForMatrix",1700,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"f - 'Float_t' 1 - sx f - 'Float_t' 1 - sy "
"f - 'Float_t' 1 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGridStep",1090,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RebinAxis",901,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"U 'TAxis' - 0 - orig U 'TAxis' - 0 - curr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAxis3DTitlePos",1644,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 4, 8, 
"u 'TGLRnrCtx' - 1 - rnrCtx f - 'Float_t' 0 - x0 "
"f - 'Float_t' 0 - x1 f - 'Float_t' 0 - y0 "
"f - 'Float_t' 0 - y1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawAxis3D",922,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawAxis2D",921,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawHistBase",1185,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawSelectedCells",1706,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >' 'TEveCaloData::vCellId_t' 0 - cells", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrepareCell2DData",1599,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"u 'vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >' 'TEveCaloData::vCellId_t' 1 - cellList u 'vector<TEveCaloLegoGL::Cell2D_t,allocator<TEveCaloLegoGL::Cell2D_t> >' 'TEveCaloLegoGL::vCell2D_t' 1 - cells2D", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrepareCell2DDataRebin",2095,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"u 'TEveCaloData::RebinData_t' - 1 - rebinData u 'vector<TEveCaloLegoGL::Cell2D_t,allocator<TEveCaloLegoGL::Cell2D_t> >' 'TEveCaloLegoGL::vCell2D_t' 1 - cells2D", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawCells2D",1015,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'vector<TEveCaloLegoGL::Cell2D_t,allocator<TEveCaloLegoGL::Cell2D_t> >' 'TEveCaloLegoGL::vCell2D_t' 1 - cells2D", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawCells3D",1016,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeQuad",777,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 4, 8, 
"f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
"f - 'Float_t' 0 - z f - 'Float_t' 0 - xw "
"f - 'Float_t' 0 - yw f - 'Float_t' 0 - zh", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Make3DDisplayList",1639,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"u 'vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >' 'TEveCaloData::vCellId_t' 1 - cellList u 'map<int,unsigned int,less<int>,allocator<pair<const int,unsigned int> > >' 'TEveCaloLegoGL::SliceDLMap_t' 1 - map "
"g - 'Bool_t' 0 - select", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Make3DDisplayListRebin",2135,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"u 'TEveCaloData::RebinData_t' - 1 - rebinData u 'map<int,unsigned int,less<int>,allocator<pair<const int,unsigned int> > >' 'TEveCaloLegoGL::SliceDLMap_t' 1 - map "
"g - 'Bool_t' 0 - select", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WrapTwoPi",909,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"f - 'Float_t' 1 - min f - 'Float_t' 1 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveCaloLegoGL",1293,G__G__Eve2_489_0_19, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoGL), -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("DLCacheDrop",1017,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DLCachePurge",1127,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawHighlight",1318,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"u 'TGLRnrCtx' - 1 - rnrCtx U 'TGLPhysicalShape' - 10 - ps "
"i - 'Int_t' 0 '-1' lvl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SupportsSecondarySelect",2424,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AlwaysSecondarySelect",2169,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessSelection",1669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'TGLSelectRecord' - 1 - rec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_489_0_29, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCaloLegoGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_489_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloLegoGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_489_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCaloLegoGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_489_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCaloLegoGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_489_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__Eve2_489_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloLegoGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_489_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloLegoGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_489_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloLegoGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_489_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloLegoGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCaloLegoGL", 1419, G__G__Eve2_489_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCaloLegoOverlay(void) {
   /* TEveCaloLegoOverlay */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoOverlay));
   G__memfunc_setup("TEveCaloLegoOverlay",1884,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoOverlay), -1, 0, 1, 1, 4, 0, "u 'TEveCaloLegoOverlay' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoOverlay), -1, 1, 1, 1, 4, 0, "u 'TEveCaloLegoOverlay' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("SetSliderVal",1202,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0, 
"U 'Event_t' - 0 - event u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderLogaritmicScales",2246,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderPaletteScales",1930,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderPlaneInterface",2017,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderHeader",1193,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveCaloLegoOverlay",1884,G__G__Eve2_490_0_8, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoOverlay), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Render",608,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MouseEnter",1031,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TGLOvlSelectRecord' - 1 - selRec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Handle",588,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'TGLOvlSelectRecord' - 1 - selRec "
"U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MouseLeave",1014,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCaloLego",1062,G__G__Eve2_490_0_13, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCaloLego",1074,G__G__Eve2_490_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveCaloLego' - 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShowPlane",1213,G__G__Eve2_490_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShowPlane",1201,G__G__Eve2_490_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHeaderTxt",1205,G__G__Eve2_490_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - txt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHeaderTxt",1193,G__G__Eve2_490_0_18, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShowScales",1320,G__G__Eve2_490_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScaleColorTransparency",2573,G__G__Eve2_490_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 - colIdx c - 'Char_t' 0 - transp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScalePosition",1641,G__G__Eve2_490_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFrameAttribs",1520,G__G__Eve2_490_0_22, 121, -1, -1, 0, 3, 1, 1, 0, 
"s - 'Color_t' 0 - frameCol c - 'Char_t' 0 - lineTransp "
"c - 'Char_t' 0 - bgTransp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_490_0_23, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCaloLegoOverlay::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_490_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloLegoOverlay::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_490_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCaloLegoOverlay::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_490_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCaloLegoOverlay::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_490_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve2_490_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloLegoOverlay::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_490_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloLegoOverlay::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_490_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloLegoOverlay::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_490_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloLegoOverlay::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCaloLegoOverlay", 2010, G__G__Eve2_490_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCaloLegoEditor(void) {
   /* TEveCaloLegoEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoEditor));
   G__memfunc_setup("TEveCaloLegoEditor",1761,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoEditor), -1, 0, 1, 1, 4, 0, "u 'TEveCaloLegoEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoEditor), -1, 1, 1, 1, 4, 0, "u 'TEveCaloLegoEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("MakeLabeledCombo",1559,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Eve2LN_TGComboBox), -1, 0, 2, 1, 4, 0, 
"C - - 10 - name i - 'Int_t' 0 - off", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeRebinFrame",1369,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveCaloLegoEditor",1761,G__G__Eve2_499_0_5, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLegoEditor), -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("DoGridColor",1080,G__G__Eve2_499_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoFontColor",1097,G__G__Eve2_499_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPlaneColor",1186,G__G__Eve2_499_0_9, 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__Eve2_499_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoProjection",1232,G__G__Eve2_499_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Do2DMode",686,G__G__Eve2_499_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoBoxMode",865,G__G__Eve2_499_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoCell2DTextMin",1394,G__G__Eve2_499_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoAutoRebin",1084,G__G__Eve2_499_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPixelsPerBin",1384,G__G__Eve2_499_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoNormalize",1124,G__G__Eve2_499_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_499_0_18, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCaloLegoEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_499_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloLegoEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_499_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCaloLegoEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_499_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCaloLegoEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_499_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__Eve2_499_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloLegoEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_499_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloLegoEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_499_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCaloLegoEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_499_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCaloLegoEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCaloLegoEditor", 1887, G__G__Eve2_499_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveCalo3DEditor(void) {
   /* TEveCalo3DEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DEditor));
   G__memfunc_setup("TEveCalo3DEditor",1489,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DEditor), -1, 0, 1, 1, 4, 0, "u 'TEveCalo3DEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DEditor), -1, 1, 1, 1, 4, 0, "u 'TEveCalo3DEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveCalo3DEditor",1489,G__G__Eve2_561_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveCalo3DEditor), -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("DoFrameTransparency",1944,G__G__Eve2_561_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_561_0_6, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveCalo3DEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_561_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCalo3DEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_561_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveCalo3DEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_561_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveCalo3DEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_561_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__Eve2_561_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCalo3DEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_561_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCalo3DEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_561_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveCalo3DEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_561_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveCalo3DEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveCalo3DEditor", 1615, G__G__Eve2_561_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGeoNode(void) {
   /* TEveGeoNode */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNode));
   G__memfunc_setup("TEveGeoNode",1045,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNode), -1, 0, 1, 1, 4, 0, "u 'TEveGeoNode' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNode), -1, 1, 1, 1, 4, 0, "u 'TEveGeoNode' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("DumpShapeTree",1303,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeExtract), -1, 0, 3, 1, 2, 0, 
"U 'TEveGeoNode' - 0 - geon U 'TEveGeoShapeExtract' - 0 '0' parent "
"g - 'Bool_t' 0 'kFALSE' leafs_only", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveGeoNode",1045,G__G__Eve2_563_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNode), -1, 0, 1, 1, 1, 0, "U 'TGeoNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObject",887,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TObject), -1, 0, 1, 1, 1, 8, "u 'TEveException' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTitle",802,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("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("GetNode",678,G__G__Eve2_563_0_10, 85, G__get_linked_tagnum(&G__G__Eve2LN_TGeoNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExpandIntoListTree",1830,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGListTree' - 0 - ltree U 'TGListTreeItem' - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExpandIntoListTrees",1945,G__G__Eve2_563_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExpandIntoListTreesRecursively",3126,G__G__Eve2_563_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CanEditElement",1378,(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("CanEditMainColor",1564,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   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("CanEditMainTransparency",2327,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMainTransparency",1951,(G__InterfaceMethod) NULL,99, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 8, "", (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("UpdateNode",1001,G__G__Eve2_563_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateVolume",1243,G__G__Eve2_563_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - volume", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Save",399,G__G__Eve2_563_0_23, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - file C - - 10 '\"Extract\"' name "
"g - 'Bool_t' 0 'kFALSE' leafs_only", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveExtract",1130,G__G__Eve2_563_0_24, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - file C - - 10 - name "
"g - 'Bool_t' 0 - leafs_only", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteExtract",1254,G__G__Eve2_563_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - name g - 'Bool_t' 0 - leafs_only", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCSGExportNSeg",1516,G__G__Eve2_563_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TEveGeoNode::GetCSGExportNSeg) ), 0);
   G__memfunc_setup("SetCSGExportNSeg",1528,G__G__Eve2_563_0_28, 121, -1, -1, 0, 1, 3, 1, 0, "i - 'Int_t' 0 - nseg", (char*)NULL, (void*) G__func2void( (void (*)(Int_t))(&TEveGeoNode::SetCSGExportNSeg) ), 0);
   G__memfunc_setup("Class",502,G__G__Eve2_563_0_29, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGeoNode::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_563_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoNode::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_563_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGeoNode::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_563_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGeoNode::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_563_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__Eve2_563_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoNode::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_563_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoNode::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_563_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoNode::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_563_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoNode::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGeoNode", 1171, G__G__Eve2_563_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGeoTopNode(void) {
   /* TEveGeoTopNode */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNode));
   G__memfunc_setup("TEveGeoTopNode",1352,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNode), -1, 0, 1, 1, 4, 0, "u 'TEveGeoTopNode' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNode), -1, 1, 1, 1, 4, 0, "u 'TEveGeoTopNode' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveGeoTopNode",1352,G__G__Eve2_564_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNode), -1, 0, 5, 1, 1, 0, 
"U 'TGeoManager' - 0 - manager U 'TGeoNode' - 0 - node "
"i - 'Int_t' 0 '1' visopt i - 'Int_t' 0 '3' vislvl "
"i - 'Int_t' 0 '10000' maxvisnds", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseNodeTrans",1211,G__G__Eve2_564_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGeoManager",1270,G__G__Eve2_564_0_5, 85, G__get_linked_tagnum(&G__G__Eve2LN_TGeoManager), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVisOption",1227,G__G__Eve2_564_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVisOption",1239,G__G__Eve2_564_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vo", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVisLevel",1098,G__G__Eve2_564_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVisLevel",1110,G__G__Eve2_564_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - vl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxVisNodes",1393,G__G__Eve2_564_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxVisNodes",1405,G__G__Eve2_564_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mvn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CanEditElement",1378,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (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("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("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (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("VolumeVisChanged",1620,G__G__Eve2_564_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - volume", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("VolumeColChanged",1600,G__G__Eve2_564_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - volume", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NodeVisChanged",1378,G__G__Eve2_564_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_564_0_20, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGeoTopNode::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_564_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoTopNode::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_564_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGeoTopNode::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_564_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGeoTopNode::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_564_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__Eve2_564_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoTopNode::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_564_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoTopNode::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_564_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoTopNode::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_564_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoTopNode::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGeoTopNode", 1478, G__G__Eve2_564_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGeoNodeEditor(void) {
   /* TEveGeoNodeEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNodeEditor));
   G__memfunc_setup("TEveGeoNodeEditor",1660,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNodeEditor), -1, 0, 1, 1, 4, 0, "u 'TEveGeoNodeEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNodeEditor), -1, 1, 1, 1, 4, 0, "u 'TEveGeoNodeEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveGeoNodeEditor",1660,G__G__Eve2_565_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoNodeEditor), -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("DoVizNode",882,G__G__Eve2_565_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoVizNodeDaughters",1817,G__G__Eve2_565_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoVizVolume",1124,G__G__Eve2_565_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoVizVolumeDaughters",2059,G__G__Eve2_565_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_565_0_9, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGeoNodeEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_565_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoNodeEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_565_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGeoNodeEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_565_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGeoNodeEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_565_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__Eve2_565_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoNodeEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_565_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoNodeEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_565_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoNodeEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_565_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoNodeEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGeoNodeEditor", 1786, G__G__Eve2_565_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGeoTopNodeEditor(void) {
   /* TEveGeoTopNodeEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNodeEditor));
   G__memfunc_setup("TEveGeoTopNodeEditor",1967,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNodeEditor), -1, 0, 1, 1, 4, 0, "u 'TEveGeoTopNodeEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNodeEditor), -1, 1, 1, 1, 4, 0, "u 'TEveGeoTopNodeEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveGeoTopNodeEditor",1967,G__G__Eve2_566_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoTopNodeEditor), -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("DoVisOption",1118,G__G__Eve2_566_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoVisLevel",989,G__G__Eve2_566_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoMaxVisNodes",1284,G__G__Eve2_566_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_566_0_8, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGeoTopNodeEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_566_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoTopNodeEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_566_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGeoTopNodeEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_566_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGeoTopNodeEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_566_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__Eve2_566_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoTopNodeEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_566_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoTopNodeEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_566_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoTopNodeEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_566_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoTopNodeEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGeoTopNodeEditor", 2093, G__G__Eve2_566_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGeoShapeExtract(void) {
   /* TEveGeoShapeExtract */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeExtract));
   G__memfunc_setup("TEveGeoShapeExtract",1883,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeExtract), -1, 0, 1, 1, 4, 0, "u 'TEveGeoShapeExtract' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeExtract), -1, 1, 1, 1, 4, 0, "u 'TEveGeoShapeExtract' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveGeoShapeExtract",1883,G__G__Eve2_572_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeExtract), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEveGeoShapeExtract\"' n C - - 10 '0' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasElements",1113,G__G__Eve2_572_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddElement",979,G__G__Eve2_572_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveGeoShapeExtract' - 0 - gse", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrans",820,G__G__Eve2_572_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - arr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRGBA",584,G__G__Eve2_572_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - arr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRGBALine",976,G__G__Eve2_572_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 10 - arr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRnrSelf",1000,G__G__Eve2_572_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRnrElements",1435,G__G__Eve2_572_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRnrFrame",1097,G__G__Eve2_572_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMiniFrame",1188,G__G__Eve2_572_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShape",797,G__G__Eve2_572_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoShape' - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetElements",1129,G__G__Eve2_572_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrans",808,G__G__Eve2_572_0_15, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRGBA",572,G__G__Eve2_572_0_16, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRGBALine",964,G__G__Eve2_572_0_17, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRnrSelf",988,G__G__Eve2_572_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRnrElements",1423,G__G__Eve2_572_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRnrFrame",1085,G__G__Eve2_572_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMiniFrame",1176,G__G__Eve2_572_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShape",785,G__G__Eve2_572_0_22, 85, G__get_linked_tagnum(&G__G__Eve2LN_TGeoShape), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetElements",1117,G__G__Eve2_572_0_23, 85, G__get_linked_tagnum(&G__G__Eve2LN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_572_0_24, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGeoShapeExtract::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_572_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoShapeExtract::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_572_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGeoShapeExtract::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_572_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGeoShapeExtract::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_572_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve2_572_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoShapeExtract::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_572_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoShapeExtract::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_572_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoShapeExtract::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_572_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoShapeExtract::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGeoShapeExtract", 2009, G__G__Eve2_572_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGeoShape(void) {
   /* TEveGeoShape */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShape));
   G__memfunc_setup("TEveGeoShape",1152,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShape), -1, 0, 1, 1, 4, 0, "u 'TEveGeoShape' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShape), -1, 1, 1, 1, 4, 0, "u 'TEveGeoShape' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("SubImportShapeExtract",2161,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShape), -1, 0, 2, 3, 2, 0, 
"U 'TEveGeoShapeExtract' - 0 - gse U 'TEveElement' - 0 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpShapeTree",1303,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeExtract), -1, 0, 2, 1, 2, 0, 
"U 'TEveGeoShape' - 0 - geon U 'TEveGeoShapeExtract' - 0 '0' parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakePolyShape",1299,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Eve2LN_TGeoShape), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveGeoShape",1152,G__G__Eve2_573_0_6, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShape), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEveGeoShape\"' name C - - 10 '0' title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObject",887,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TObject), -1, 0, 1, 1, 1, 8, "u 'TEveException' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNSegments",1204,G__G__Eve2_573_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShape",785,G__G__Eve2_573_0_9, 85, G__get_linked_tagnum(&G__G__Eve2LN_TGeoShape), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNSegments",1216,G__G__Eve2_573_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShape",797,G__G__Eve2_573_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoShape' - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (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("Save",399,G__G__Eve2_573_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - file C - - 10 '\"Extract\"' name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveExtract",1130,G__G__Eve2_573_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - file C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteExtract",1254,G__G__Eve2_573_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ImportShapeExtract",1863,G__G__Eve2_573_0_17, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShape), -1, 0, 2, 3, 1, 0, 
"U 'TEveGeoShapeExtract' - 0 - gse U 'TEveElement' - 0 '0' parent", (char*)NULL, (void*) G__func2void( (TEveGeoShape* (*)(TEveGeoShapeExtract*, TEveElement*))(&TEveGeoShape::ImportShapeExtract) ), 0);
   G__memfunc_setup("MakeBuffer3D",1103,G__G__Eve2_573_0_18, 85, G__get_linked_tagnum(&G__G__Eve2LN_TBuffer3D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProjectedClass",1430,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 1, 1, 1, 8, "U 'TEveProjection' - 10 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGeoMangeur",1290,G__G__Eve2_573_0_20, 85, G__get_linked_tagnum(&G__G__Eve2LN_TGeoManager), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TGeoManager* (*)())(&TEveGeoShape::GetGeoMangeur) ), 0);
   G__memfunc_setup("Class",502,G__G__Eve2_573_0_21, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGeoShape::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_573_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoShape::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_573_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGeoShape::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_573_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGeoShape::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_573_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__Eve2_573_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoShape::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_573_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoShape::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_573_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoShape::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_573_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoShape::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGeoShape", 1278, G__G__Eve2_573_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGeoShapeProjected(void) {
   /* TEveGeoShapeProjected */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeProjected));
   G__memfunc_setup("TEveGeoShapeProjected",2080,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeProjected), -1, 0, 1, 1, 4, 0, "u 'TEveGeoShapeProjected' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeProjected), -1, 1, 1, 1, 4, 0, "u 'TEveGeoShapeProjected' - 11 - -", "Not implemented", (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("TEveGeoShapeProjected",2080,G__G__Eve2_574_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoShapeProjected), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProjection",1353,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveProjectionManager' - 0 - proj U 'TEveProjectable' - 0 - model", (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__Eve2LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (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__Eve2_574_0_9, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGeoShapeProjected::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_574_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoShapeProjected::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_574_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGeoShapeProjected::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_574_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGeoShapeProjected::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_574_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__Eve2_574_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoShapeProjected::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_574_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoShapeProjected::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_574_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoShapeProjected::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_574_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoShapeProjected::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGeoShapeProjected", 2206, G__G__Eve2_574_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGeoPolyShape(void) {
   /* TEveGeoPolyShape */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoPolyShape));
   G__memfunc_setup("TEveGeoPolyShape",1572,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoPolyShape), -1, 0, 1, 1, 4, 0, "u 'TEveGeoPolyShape' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoPolyShape), -1, 1, 1, 1, 4, 0, "u 'TEveGeoPolyShape' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("FillBuffer3D",1112,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 8, 
"u 'TBuffer3D' - 1 - buffer i - 'Int_t' 0 - reqSections "
"g - 'Bool_t' 0 - localFrame", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TEveGeoPolyShape",1572,G__G__Eve2_583_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoPolyShape), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Construct",965,G__G__Eve2_583_0_5, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveGeoPolyShape), -1, 0, 2, 3, 1, 0, 
"U 'TGeoCompositeShape' - 0 - cshp i - 'Int_t' 0 - n_seg", (char*)NULL, (void*) G__func2void( (TEveGeoPolyShape* (*)(TGeoCompositeShape*, Int_t))(&TEveGeoPolyShape::Construct) ), 0);
   G__memfunc_setup("SetFromFaceSet",1371,G__G__Eve2_583_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGLFaceSet' - 0 - fs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Eve2LN_TBuffer3D), -1, 1, 2, 1, 1, 9, 
"i - 'Int_t' 0 - reqSections g - 'Bool_t' 0 - localFrame", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeBuffer3D",1103,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TBuffer3D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_583_0_9, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGeoPolyShape::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_583_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoPolyShape::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_583_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGeoPolyShape::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_583_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGeoPolyShape::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_583_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__Eve2_583_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoPolyShape::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_583_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoPolyShape::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_583_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGeoPolyShape::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_583_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGeoPolyShape::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGeoPolyShape", 1698, G__G__Eve2_583_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGridStepper(void) {
   /* TEveGridStepper */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepper));
   G__memfunc_setup("TEveGridStepper",1501,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepper), -1, 0, 1, 1, 4, 0, "u 'TEveGridStepper' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepper), -1, 1, 1, 1, 4, 0, "u 'TEveGridStepper' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveGridStepper",1501,G__G__Eve2_586_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepper), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 'kSM_XYZ' sm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Eve2_586_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Subtract",840,G__G__Eve2_586_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEveGridStepper' - 1 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNs",493,G__G__Eve2_586_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nx i - 'Int_t' 0 - ny "
"i - 'Int_t' 0 '1' nz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDs",483,G__G__Eve2_586_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - dx f - 'Float_t' 0 - dy "
"f - 'Float_t' 0 '0' dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOs",494,G__G__Eve2_586_0_8, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - ox f - 'Float_t' 0 - oy "
"f - 'Float_t' 0 '0' oz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Step",412,G__G__Eve2_586_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPosition",1141,G__G__Eve2_586_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrans",820,G__G__Eve2_586_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveTrans' - 0 - mx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTransAdvance",1510,G__G__Eve2_586_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveTrans' - 0 - mx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCx",475,G__G__Eve2_586_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCy",476,G__G__Eve2_586_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCz",477,G__G__Eve2_586_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNx",486,G__G__Eve2_586_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNy",487,G__G__Eve2_586_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNz",488,G__G__Eve2_586_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDx",476,G__G__Eve2_586_0_19, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDy",477,G__G__Eve2_586_0_20, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDz",478,G__G__Eve2_586_0_21, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOx",487,G__G__Eve2_586_0_22, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOy",488,G__G__Eve2_586_0_23, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOz",489,G__G__Eve2_586_0_24, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_586_0_25, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGridStepper::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_586_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGridStepper::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_586_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGridStepper::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_586_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGridStepper::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_586_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__Eve2_586_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGridStepper::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_586_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGridStepper::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_586_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGridStepper::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_586_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGridStepper::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGridStepper", 1627, G__G__Eve2_586_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGridStepperSubEditor(void) {
   /* TEveGridStepperSubEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperSubEditor));
   G__memfunc_setup("TEveGridStepperSubEditor",2414,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperSubEditor), -1, 0, 1, 1, 4, 0, "u 'TEveGridStepperSubEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperSubEditor), -1, 1, 1, 1, 4, 0, "u 'TEveGridStepperSubEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveGridStepperSubEditor",2414,G__G__Eve2_587_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperSubEditor), -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 10 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,G__G__Eve2_587_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveGridStepper' - 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Changed",682,G__G__Eve2_587_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("DoNs",372,G__G__Eve2_587_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDs",362,G__G__Eve2_587_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_587_0_8, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGridStepperSubEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_587_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGridStepperSubEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_587_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGridStepperSubEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_587_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGridStepperSubEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_587_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__Eve2_587_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGridStepperSubEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_587_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGridStepperSubEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_587_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGridStepperSubEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_587_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGridStepperSubEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGridStepperSubEditor", 2540, G__G__Eve2_587_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveGridStepperEditor(void) {
   /* TEveGridStepperEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperEditor));
   G__memfunc_setup("TEveGridStepperEditor",2116,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperEditor), -1, 0, 1, 1, 4, 0, "u 'TEveGridStepperEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperEditor), -1, 1, 1, 1, 4, 0, "u 'TEveGridStepperEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveGridStepperEditor",2116,G__G__Eve2_588_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveGridStepperEditor), -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__Eve2_588_0_5, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveGridStepperEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_588_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGridStepperEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_588_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveGridStepperEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_588_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveGridStepperEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_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__Eve2_588_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGridStepperEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_588_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGridStepperEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_588_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveGridStepperEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_588_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveGridStepperEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveGridStepperEditor", 2242, G__G__Eve2_588_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveLegoEventHandler(void) {
   /* TEveLegoEventHandler */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLegoEventHandler));
   G__memfunc_setup("TEveLegoEventHandler",1979,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveLegoEventHandler), -1, 0, 1, 1, 4, 0, "u 'TEveLegoEventHandler' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveLegoEventHandler), -1, 1, 1, 1, 4, 0, "u 'TEveLegoEventHandler' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("Rotate",623,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 2, 0, 
"i - 'Int_t' 0 - xDelta i - 'Int_t' 0 - yDelta "
"g - 'Bool_t' 0 - mod1 g - 'Bool_t' 0 - mod2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TEveLegoEventHandler",1979,G__G__Eve2_593_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveLegoEventHandler), -1, 0, 3, 1, 1, 0, 
"U 'TGWindow' - 0 - w U 'TObject' - 0 - obj "
"U 'TEveCaloLego' - 0 '0' lego", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HandleKey",885,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTransTheta",1310,G__G__Eve2_593_0_6, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTransTheta",1322,G__G__Eve2_593_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLego",679,G__G__Eve2_593_0_8, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveCaloLego), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLego",691,G__G__Eve2_593_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveCaloLego' - 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_593_0_10, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveLegoEventHandler::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_593_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveLegoEventHandler::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_593_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveLegoEventHandler::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_593_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveLegoEventHandler::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_593_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__Eve2_593_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveLegoEventHandler::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_593_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveLegoEventHandler::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_593_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveLegoEventHandler::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_593_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveLegoEventHandler::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveLegoEventHandler", 2105, G__G__Eve2_593_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveLine(void) {
   /* TEveLine */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLine));
   G__memfunc_setup("TEveLine",764,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveLine), -1, 0, 1, 1, 4, 0, "u 'TEveLine' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveLine), -1, 1, 1, 1, 4, 0, "u 'TEveLine' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveLine",764,G__G__Eve2_595_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveLine), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '0' n_points i 'TEvePointSelectorConsumer::ETreeVarType_e' - 0 'kTVT_XYZ' tv_type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveLine",764,G__G__Eve2_595_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveLine), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 '0' n_points "
"i 'TEvePointSelectorConsumer::ETreeVarType_e' - 0 'kTVT_XYZ' tv_type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMarkerColor",1421,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - col", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineColor",1203,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - col", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineStyle",1221,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - lstyle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineWidth",1204,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 - lwidth", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRnrLine",986,G__G__Eve2_595_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRnrPoints",1231,G__G__Eve2_595_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSmooth",922,G__G__Eve2_595_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRnrLine",998,G__G__Eve2_595_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRnrPoints",1243,G__G__Eve2_595_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSmooth",934,G__G__Eve2_595_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReduceSegmentLengths",2048,G__G__Eve2_595_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLineStart",1206,G__G__Eve2_595_0_16, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR), G__defined_typename("TEveVector"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLineEnd",959,G__G__Eve2_595_0_17, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR), G__defined_typename("TEveVector"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListTreeIcon",1493,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TGPicture), -1, 0, 1, 1, 1, 1, "g - 'Bool_t' 0 'kFALSE' open", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyVizParams",1336,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 10 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteVizParams",1448,(G__InterfaceMethod) NULL,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("ProjectedClass",1430,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 1, 1, 1, 8, "U 'TEveProjection' - 10 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultSmooth",1631,G__G__Eve2_595_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TEveLine::GetDefaultSmooth) ), 0);
   G__memfunc_setup("SetDefaultSmooth",1643,G__G__Eve2_595_0_23, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - r", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TEveLine::SetDefaultSmooth) ), 0);
   G__memfunc_setup("Class",502,G__G__Eve2_595_0_24, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveLine::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_595_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveLine::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_595_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveLine::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_595_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveLine::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_595_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve2_595_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveLine::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_595_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveLine::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_595_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveLine::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_595_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveLine::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveLine", 890, G__G__Eve2_595_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveLineEditor(void) {
   /* TEveLineEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineEditor));
   G__memfunc_setup("TEveLineEditor",1379,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveLineEditor), -1, 0, 1, 1, 4, 0, "u 'TEveLineEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveLineEditor), -1, 1, 1, 1, 4, 0, "u 'TEveLineEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveLineEditor",1379,G__G__Eve2_596_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveLineEditor), -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("DoRnrLine",877,G__G__Eve2_596_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRnrPoints",1122,G__G__Eve2_596_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoSmooth",813,G__G__Eve2_596_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_596_0_8, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveLineEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_596_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveLineEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_596_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveLineEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_596_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveLineEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_596_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__Eve2_596_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveLineEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_596_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveLineEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_596_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveLineEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_596_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveLineEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveLineEditor", 1505, G__G__Eve2_596_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveLineGL(void) {
   /* TEveLineGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineGL));
   G__memfunc_setup("TEveLineGL",911,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveLineGL), -1, 0, 1, 1, 4, 0, "u 'TEveLineGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveLineGL), -1, 1, 1, 1, 4, 0, "u 'TEveLineGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveLineGL",911,G__G__Eve2_598_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveLineGL), -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("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_598_0_6, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveLineGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_598_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveLineGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_598_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveLineGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_598_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveLineGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_598_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__Eve2_598_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveLineGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_598_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveLineGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_598_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveLineGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_598_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveLineGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveLineGL", 1037, G__G__Eve2_598_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvePointSet(void) {
   /* TEvePointSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet), -1, 1, 1, 1, 4, 0, "u 'TEvePointSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("AssertIntIdsSize",1624,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEvePointSet",1194,G__G__Eve2_622_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '0' n_points i 'TEvePointSelectorConsumer::ETreeVarType_e' - 0 'kTVT_XYZ' tv_type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEvePointSet",1194,G__G__Eve2_622_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 '0' n_points "
"i 'TEvePointSelectorConsumer::ETreeVarType_e' - 0 'kTVT_XYZ' tv_type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEvePointSet",1194,G__G__Eve2_622_0_5, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet), -1, 0, 1, 1, 1, 0, "u 'TEvePointSet' - 11 - e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObject",887,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TObject), -1, 0, 1, 1, 1, 8, "u 'TEveException' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloneElement",1211,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClonePoints",1134,G__G__Eve2_622_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEvePointSet' - 11 - e", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__Eve2_622_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '0' n_points i - 'Int_t' 0 '0' n_int_ids", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GrowFor",710,G__G__Eve2_622_0_10, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n_points", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTitle",802,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("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 - n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTitle",814,G__G__Eve2_622_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetElementTitle",1528,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetElementNameTitle",1913,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - n C - - 10 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIntIdsPerPoint",1692,G__G__Eve2_622_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPointIntIds",1397,G__G__Eve2_622_0_19, 73, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPointIntId",1282,G__G__Eve2_622_0_20, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - p i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPointIntIds",1409,G__G__Eve2_622_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "I - 'Int_t' 0 - ids", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPointIntIds",1409,G__G__Eve2_622_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n I - 'Int_t' 0 - ids", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMarkerColor",1421,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - col", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMarkerStyle",1439,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '1' mstyle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMarkerSize",1321,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "f - 'Size_t' 0 '1' msize", (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("InitFill",795,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - subIdNum", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TakeAction",995,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvePointSelector' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PointSelected",1331,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("GetListTreeIcon",1493,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TGPicture), -1, 0, 1, 1, 1, 1, "g - 'Bool_t' 0 'kFALSE' open", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyVizParams",1336,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 10 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteVizParams",1448,(G__InterfaceMethod) NULL,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("ProjectedClass",1430,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 1, 1, 1, 8, "U 'TEveProjection' - 10 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_622_0_34, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvePointSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_622_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_622_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvePointSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_622_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvePointSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_622_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve2_622_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_622_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePointSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_622_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_622_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePointSet::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEvePointSet", 1320, G__G__Eve2_622_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvePointSetArray(void) {
   /* TEvePointSetArray */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArray));
   G__memfunc_setup("TEvePointSetArray",1705,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArray), -1, 0, 1, 1, 4, 0, "u 'TEvePointSetArray' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArray), -1, 1, 1, 1, 4, 0, "u 'TEvePointSetArray' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEvePointSetArray",1705,G__G__Eve2_623_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArray), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEvePointSetArray\"' name C - - 10 '\"\"' title", (char*)NULL, (void*) NULL, 0);
   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("SetMarkerColor",1421,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 '1' tcolor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMarkerStyle",1439,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '1' mstyle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMarkerSize",1321,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "f - 'Size_t' 0 '1' msize", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TakeAction",995,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEvePointSelector' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Size",411,G__G__Eve2_623_0_10, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"g - 'Bool_t' 0 'kFALSE' under g - 'Bool_t' 0 'kFALSE' over", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitBins",800,G__G__Eve2_623_0_11, 121, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 - quant_name i - 'Int_t' 0 - nbins "
"d - 'Double_t' 0 - min d - 'Double_t' 0 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,G__G__Eve2_623_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - quant", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPointId",995,G__G__Eve2_623_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseBins",898,G__G__Eve2_623_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOwnIds",896,G__G__Eve2_623_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - o", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefPointSetCapacity",2195,G__G__Eve2_623_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDefPointSetCapacity",2207,G__G__Eve2_623_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNBins",762,G__G__Eve2_623_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBin",569,G__G__Eve2_623_0_19, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSet), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - bin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMin",580,G__G__Eve2_623_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurMin",878,G__G__Eve2_623_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMax",582,G__G__Eve2_623_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurMax",880,G__G__Eve2_623_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRange",793,G__G__Eve2_623_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - min d - 'Double_t' 0 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_623_0_25, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvePointSetArray::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_623_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSetArray::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_623_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvePointSetArray::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_623_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvePointSetArray::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_623_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__Eve2_623_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSetArray::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_623_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePointSetArray::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_623_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSetArray::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_623_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePointSetArray::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEvePointSetArray", 1831, G__G__Eve2_623_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvePointSetArrayEditor(void) {
   /* TEvePointSetArrayEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArrayEditor));
   G__memfunc_setup("TEvePointSetArrayEditor",2320,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArrayEditor), -1, 0, 1, 1, 4, 0, "u 'TEvePointSetArrayEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArrayEditor), -1, 1, 1, 1, 4, 0, "u 'TEvePointSetArrayEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEvePointSetArrayEditor",2320,G__G__Eve2_624_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetArrayEditor), -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("DoRange",672,G__G__Eve2_624_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_624_0_6, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvePointSetArrayEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_624_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSetArrayEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_624_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvePointSetArrayEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_624_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvePointSetArrayEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_624_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__Eve2_624_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSetArrayEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_624_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePointSetArrayEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_624_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSetArrayEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_624_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePointSetArrayEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEvePointSetArrayEditor", 2446, G__G__Eve2_624_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvePointSetProjected(void) {
   /* TEvePointSetProjected */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected));
   G__memfunc_setup("TEvePointSetProjected",2122,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected), -1, 0, 1, 1, 4, 0, "u 'TEvePointSetProjected' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected), -1, 1, 1, 1, 4, 0, "u 'TEvePointSetProjected' - 11 - -", "Not implemented", (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("TEvePointSetProjected",2122,G__G__Eve2_625_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEvePointSetProjected), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProjection",1353,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveProjectionManager' - 0 - proj U 'TEveProjectable' - 0 - model", (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__Eve2LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PointSelected",1331,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_625_0_9, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvePointSetProjected::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_625_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSetProjected::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_625_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvePointSetProjected::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_625_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvePointSetProjected::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_625_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__Eve2_625_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSetProjected::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_625_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePointSetProjected::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_625_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePointSetProjected::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_625_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePointSetProjected::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEvePointSetProjected", 2248, G__G__Eve2_625_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveLineProjected(void) {
   /* TEveLineProjected */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected));
   G__memfunc_setup("TEveLineProjected",1692,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected), -1, 0, 1, 1, 4, 0, "u 'TEveLineProjected' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected), -1, 1, 1, 1, 4, 0, "u 'TEveLineProjected' - 11 - -", "Not implemented", (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("TEveLineProjected",1692,G__G__Eve2_626_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveLineProjected), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProjection",1353,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveProjectionManager' - 0 - mng U 'TEveProjectable' - 0 - model", (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__Eve2LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_626_0_8, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveLineProjected::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_626_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveLineProjected::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_626_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveLineProjected::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_626_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveLineProjected::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_626_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__Eve2_626_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveLineProjected::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_626_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveLineProjected::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_626_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveLineProjected::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_626_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveLineProjected::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveLineProjected", 1818, G__G__Eve2_626_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvePolygonSetProjected(void) {
   /* TEvePolygonSetProjected */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected));
   G__memfunc_setup("TEvePolygonSetProjected",2344,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected), -1, 0, 1, 1, 4, 0, "u 'TEvePolygonSetProjected' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected), -1, 1, 1, 1, 4, 0, "u 'TEvePolygonSetProjected' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("IsFirstIdxHead",1371,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0, 
"i - 'Int_t' 0 - s0 i - 'Int_t' 0 - s1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPolygon",1009,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 2, 1, 4, 0, 
"u 'list<int,allocator<int> >' 'list<Int_t,std::allocator<Int_t> >' 1 - pp u 'list<TEvePolygonSetProjected::Polygon_t,allocator<TEvePolygonSetProjected::Polygon_t> >' - 1 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProjectAndReducePoints",2239,(G__InterfaceMethod) NULL, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakePolygonsFromBP",1791,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 4, 0, "I - 'Int_t' 0 - idxMap", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakePolygonsFromBS",1794,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 4, 0, "I - 'Int_t' 0 - idxMap", (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("PolygonSurfaceXY",1634,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 2, 8, "u 'TEvePolygonSetProjected::Polygon_t' - 11 - poly", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEvePolygonSetProjected",2344,G__G__Eve2_627_0_10, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjected), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEvePolygonSetProjected\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetProjection",1353,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveProjectionManager' - 0 - mng U 'TEveProjectable' - 0 - model", (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__Eve2LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProjectBuffer3D",1448,G__G__Eve2_627_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpPolys",941,G__G__Eve2_627_0_16, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DumpBuffer3D",1127,G__G__Eve2_627_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_627_0_18, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvePolygonSetProjected::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_627_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePolygonSetProjected::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_627_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvePolygonSetProjected::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_627_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvePolygonSetProjected::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_627_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__Eve2_627_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePolygonSetProjected::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_627_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePolygonSetProjected::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_627_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePolygonSetProjected::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_627_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePolygonSetProjected::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEvePolygonSetProjected", 2470, G__G__Eve2_627_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvePolygonSetProjectedGL(void) {
   /* TEvePolygonSetProjectedGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjectedGL));
   G__memfunc_setup("TEvePolygonSetProjectedGL",2491,G__G__Eve2_628_0_1, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEvePolygonSetProjectedGL), -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("DrawHighlight",1318,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"u 'TGLRnrCtx' - 1 - rnrCtx U 'TGLPhysicalShape' - 10 - pshp "
"i - 'Int_t' 0 '-1' lvl", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IgnoreSizeForOfInterest",2345,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawOutline",1134,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_628_0_9, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvePolygonSetProjectedGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_628_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePolygonSetProjectedGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_628_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvePolygonSetProjectedGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_628_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvePolygonSetProjectedGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_628_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__Eve2_628_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePolygonSetProjectedGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_628_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePolygonSetProjectedGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_628_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePolygonSetProjectedGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_628_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePolygonSetProjectedGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEvePolygonSetProjectedGL", 2617, G__G__Eve2_628_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveQuadSet(void) {
   /* TEveQuadSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet));
   G__memfunc_setup("TEveQuadSet",1067,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet), -1, 0, 1, 1, 4, 0, "u 'TEveQuadSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet), -1, 1, 1, 1, 4, 0, "u 'TEveQuadSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("SizeofAtom",1025,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 2, 0, "i 'TEveQuadSet::EQuadType_e' - 0 - qt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveQuadSet",1067,G__G__Eve2_639_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEveQuadSet\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveQuadSet",1067,G__G__Eve2_639_0_5, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSet), -1, 0, 5, 1, 1, 0, 
"i 'TEveQuadSet::EQuadType_e' - 0 - quadType g - 'Bool_t' 0 - valIsCol "
"i - 'Int_t' 0 - chunkSize C - - 10 '\"TEveQuadSet\"' n "
"C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Eve2_639_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
"i 'TEveQuadSet::EQuadType_e' - 0 - quadType g - 'Bool_t' 0 - valIsCol "
"i - 'Int_t' 0 - chunkSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefWidth",1071,G__G__Eve2_639_0_7, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefHeight",1160,G__G__Eve2_639_0_8, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefCoord",1062,G__G__Eve2_639_0_9, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDefWidth",1083,G__G__Eve2_639_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDefHeight",1172,G__G__Eve2_639_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDefCoord",1074,G__G__Eve2_639_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddQuad",660,G__G__Eve2_639_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 0 - verts", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddQuad",660,G__G__Eve2_639_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - a f - 'Float_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddQuad",660,G__G__Eve2_639_0_15, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - a f - 'Float_t' 0 - b "
"f - 'Float_t' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddQuad",660,G__G__Eve2_639_0_16, 121, -1, -1, 0, 4, 1, 1, 0, 
"f - 'Float_t' 0 - a f - 'Float_t' 0 - b "
"f - 'Float_t' 0 - w f - 'Float_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddQuad",660,G__G__Eve2_639_0_17, 121, -1, -1, 0, 5, 1, 1, 0, 
"f - 'Float_t' 0 - a f - 'Float_t' 0 - b "
"f - 'Float_t' 0 - c f - 'Float_t' 0 - w "
"f - 'Float_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddLine",657,G__G__Eve2_639_0_18, 121, -1, -1, 0, 4, 1, 1, 0, 
"f - 'Float_t' 0 - a f - 'Float_t' 0 - b "
"f - 'Float_t' 0 - w f - 'Float_t' 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddHexagon",979,G__G__Eve2_639_0_19, 121, -1, -1, 0, 4, 1, 1, 0, 
"f - 'Float_t' 0 - a f - 'Float_t' 0 - b "
"f - 'Float_t' 0 - z f - 'Float_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("QuadValue",904,G__G__Eve2_639_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("QuadColor",906,G__G__Eve2_639_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - ci", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("QuadColor",906,G__G__Eve2_639_0_22, 121, -1, -1, 0, 4, 1, 1, 0, 
"b - 'UChar_t' 0 - r b - 'UChar_t' 0 - g "
"b - 'UChar_t' 0 - b b - 'UChar_t' 0 '255' a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("QuadId",568,G__G__Eve2_639_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - id", (char*)NULL, (void*) NULL, 0);
   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__Eve2_639_0_25, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveQuadSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_639_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveQuadSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_639_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveQuadSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_639_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveQuadSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_639_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__Eve2_639_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveQuadSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_639_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveQuadSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_639_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveQuadSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_639_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveQuadSet::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveQuadSet", 1193, G__G__Eve2_639_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveQuadSetGL(void) {
   /* TEveQuadSetGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetGL));
   G__memfunc_setup("TEveQuadSetGL",1214,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetGL), -1, 0, 1, 1, 4, 0, "u 'TEveQuadSetGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetGL), -1, 1, 1, 1, 4, 0, "u 'TEveQuadSetGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("RenderQuads",1118,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderLines",1115,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderHexagons",1437,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveQuadSetGL",1214,G__G__Eve2_640_0_6, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveQuadSetGL), -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("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__Eve2_640_0_10, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveQuadSetGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_640_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveQuadSetGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_640_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveQuadSetGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_640_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveQuadSetGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_640_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__Eve2_640_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveQuadSetGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_640_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveQuadSetGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_640_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveQuadSetGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_640_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveQuadSetGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveQuadSetGL", 1340, G__G__Eve2_640_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveStraightLineSet(void) {
   /* TEveStraightLineSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet));
   G__memfunc_setup("TEveStraightLineSet",1902,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet), -1, 0, 1, 1, 4, 0, "u 'TEveStraightLineSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet), -1, 1, 1, 1, 4, 0, "u 'TEveStraightLineSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveStraightLineSet",1902,G__G__Eve2_687_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSet), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"StraightLineSet\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLineColor",1203,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - col", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddLine",657,G__G__Eve2_687_0_5, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetcLcLLine_t), -1, 0, 6, 1, 1, 0, 
"f - 'Float_t' 0 - x1 f - 'Float_t' 0 - y1 "
"f - 'Float_t' 0 - z1 f - 'Float_t' 0 - x2 "
"f - 'Float_t' 0 - y2 f - 'Float_t' 0 - z2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddLine",657,G__G__Eve2_687_0_6, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetcLcLLine_t), -1, 0, 2, 1, 1, 0, 
"u 'TEveVectorT<float>' 'TEveVector' 11 - p1 u 'TEveVectorT<float>' 'TEveVector' 11 - p2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMarker",875,G__G__Eve2_687_0_7, 83, -1, G__defined_typename("Marker_t"), 0, 4, 1, 1, 0, 
"f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
"f - 'Float_t' 0 - z i - 'Int_t' 0 '-1' line_id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMarker",875,G__G__Eve2_687_0_8, 83, -1, G__defined_typename("Marker_t"), 0, 2, 1, 1, 0, 
"u 'TEveVectorT<float>' 'TEveVector' 11 - p i - 'Int_t' 0 '-1' line_id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMarker",875,G__G__Eve2_687_0_9, 83, -1, G__defined_typename("Marker_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - line_id f - 'Float_t' 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLine",692,G__G__Eve2_687_0_10, 121, -1, -1, 0, 7, 1, 1, 0, 
"i - - 0 - idx f - 'Float_t' 0 - x1 "
"f - 'Float_t' 0 - y1 f - 'Float_t' 0 - z1 "
"f - 'Float_t' 0 - x2 f - 'Float_t' 0 - y2 "
"f - 'Float_t' 0 - z2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLine",692,G__G__Eve2_687_0_11, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - - 0 - idx u 'TEveVectorT<float>' 'TEveVector' 11 - p1 "
"u 'TEveVectorT<float>' 'TEveVector' 11 - p2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLinePlex",1089,G__G__Eve2_687_0_12, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveChunkManager), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMarkerPlex",1307,G__G__Eve2_687_0_13, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveChunkManager), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRnrMarkers",1319,G__G__Eve2_687_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRnrLines",1101,G__G__Eve2_687_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDepthTest",1205,G__G__Eve2_687_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRnrMarkers",1331,G__G__Eve2_687_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRnrLines",1113,G__G__Eve2_687_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDepthTest",1217,G__G__Eve2_687_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyVizParams",1336,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 10 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteVizParams",1448,(G__InterfaceMethod) NULL,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("ProjectedClass",1430,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 1, 1, 1, 8, "U 'TEveProjection' - 10 - p", (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("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("Class",502,G__G__Eve2_687_0_25, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveStraightLineSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_687_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveStraightLineSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_687_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveStraightLineSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_687_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveStraightLineSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_687_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__Eve2_687_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveStraightLineSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_687_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveStraightLineSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_687_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveStraightLineSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_687_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveStraightLineSet::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveStraightLineSet", 2028, G__G__Eve2_687_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveStraightLineSetProjected(void) {
   /* TEveStraightLineSetProjected */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected));
   G__memfunc_setup("TEveStraightLineSetProjected",2830,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected), -1, 0, 1, 1, 4, 0, "u 'TEveStraightLineSetProjected' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected), -1, 1, 1, 1, 4, 0, "u 'TEveStraightLineSetProjected' - 11 - -", "Not implemented", (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("TEveStraightLineSetProjected",2830,G__G__Eve2_690_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetProjected), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProjection",1353,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveProjectionManager' - 0 - mng U 'TEveProjectable' - 0 - model", (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__Eve2LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_690_0_8, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveStraightLineSetProjected::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_690_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveStraightLineSetProjected::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_690_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveStraightLineSetProjected::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_690_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveStraightLineSetProjected::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_690_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__Eve2_690_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveStraightLineSetProjected::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_690_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveStraightLineSetProjected::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_690_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveStraightLineSetProjected::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_690_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveStraightLineSetProjected::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveStraightLineSetProjected", 2956, G__G__Eve2_690_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveScalableStraightLineSet(void) {
   /* TEveScalableStraightLineSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveScalableStraightLineSet));
   G__memfunc_setup("TEveScalableStraightLineSet",2693,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveScalableStraightLineSet), -1, 0, 1, 1, 4, 0, "u 'TEveScalableStraightLineSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveScalableStraightLineSet), -1, 1, 1, 1, 4, 0, "u 'TEveScalableStraightLineSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveScalableStraightLineSet",2693,G__G__Eve2_691_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveScalableStraightLineSet), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"ScalableStraightLineSet\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScaleCenter",1397,G__G__Eve2_691_0_4, 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("SetScale",788,G__G__Eve2_691_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScale",776,G__G__Eve2_691_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_691_0_7, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveScalableStraightLineSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_691_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveScalableStraightLineSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_691_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveScalableStraightLineSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_691_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveScalableStraightLineSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_691_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__Eve2_691_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveScalableStraightLineSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_691_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveScalableStraightLineSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_691_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveScalableStraightLineSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_691_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveScalableStraightLineSet::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveScalableStraightLineSet", 2819, G__G__Eve2_691_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveStraightLineSetEditor(void) {
   /* TEveStraightLineSetEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetEditor));
   G__memfunc_setup("TEveStraightLineSetEditor",2517,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetEditor), -1, 0, 1, 1, 4, 0, "u 'TEveStraightLineSetEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetEditor), -1, 1, 1, 1, 4, 0, "u 'TEveStraightLineSetEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveStraightLineSetEditor",2517,G__G__Eve2_692_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetEditor), -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("DoRnrMarkers",1210,G__G__Eve2_692_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRnrLines",992,G__G__Eve2_692_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_692_0_7, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveStraightLineSetEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_692_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveStraightLineSetEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_692_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveStraightLineSetEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_692_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveStraightLineSetEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_692_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__Eve2_692_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveStraightLineSetEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_692_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveStraightLineSetEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_692_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveStraightLineSetEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_692_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveStraightLineSetEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveStraightLineSetEditor", 2643, G__G__Eve2_692_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveStraightLineSetGL(void) {
   /* TEveStraightLineSetGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetGL));
   G__memfunc_setup("TEveStraightLineSetGL",2049,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetGL), -1, 0, 1, 1, 4, 0, "u 'TEveStraightLineSetGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetGL), -1, 1, 1, 1, 4, 0, "u 'TEveStraightLineSetGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveStraightLineSetGL",2049,G__G__Eve2_693_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveStraightLineSetGL), -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("ShouldDLCache",1235,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 11 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SupportsSecondarySelect",2424,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessSelection",1669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'TGLSelectRecord' - 1 - rec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_693_0_12, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveStraightLineSetGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_693_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveStraightLineSetGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_693_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveStraightLineSetGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_693_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveStraightLineSetGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_693_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__Eve2_693_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveStraightLineSetGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_693_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveStraightLineSetGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_693_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveStraightLineSetGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_693_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveStraightLineSetGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveStraightLineSetGL", 2175, G__G__Eve2_693_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveText(void) {
   /* TEveText */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveText));
   G__memfunc_setup("TEveText",793,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveText), -1, 0, 1, 1, 4, 0, "u 'TEveText' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveText), -1, 1, 1, 1, 4, 0, "u 'TEveText' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveText",793,G__G__Eve2_695_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveText), -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' txt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontSize",1106,G__G__Eve2_695_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontFile",1079,G__G__Eve2_695_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFontMode",1084,G__G__Eve2_695_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFontSize",1118,G__G__Eve2_695_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - size g - 'Bool_t' 0 'kTRUE' validate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFontFile",1091,G__G__Eve2_695_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFontFile",1091,G__G__Eve2_695_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFontMode",1096,G__G__Eve2_695_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetText",709,G__G__Eve2_695_0_11, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetText",721,G__G__Eve2_695_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLighting",1110,G__G__Eve2_695_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLighting",1122,G__G__Eve2_695_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - isOn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAutoLighting",1519,G__G__Eve2_695_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAutoLighting",1531,G__G__Eve2_695_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - isOn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExtrude",1025,G__G__Eve2_695_0_17, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetExtrude",1037,G__G__Eve2_695_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPolygonOffset",1647,G__G__Eve2_695_0_19, 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("SetPolygonOffset",1659,G__G__Eve2_695_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - factor f - 'Float_t' 0 - units", (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__Eve2LN_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__Eve2_695_0_24, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveText::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_695_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveText::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_695_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveText::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_695_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveText::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_695_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve2_695_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveText::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_695_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveText::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_695_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveText::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_695_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveText::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveText", 919, G__G__Eve2_695_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTextEditor(void) {
   /* TEveTextEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTextEditor));
   G__memfunc_setup("TEveTextEditor",1408,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTextEditor), -1, 0, 1, 1, 4, 0, "u 'TEveTextEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveTextEditor), -1, 1, 1, 1, 4, 0, "u 'TEveTextEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("MakeLabeledCombo",1559,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Eve2LN_TGComboBox), -1, 0, 1, 1, 4, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveTextEditor",1408,G__G__Eve2_696_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTextEditor), -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("DoText",600,G__G__Eve2_696_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoFontSize",997,G__G__Eve2_696_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoFontFile",970,G__G__Eve2_696_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoFontMode",975,G__G__Eve2_696_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoLighting",1001,G__G__Eve2_696_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoAutoLighting",1410,G__G__Eve2_696_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoExtrude",916,G__G__Eve2_696_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_696_0_13, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTextEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_696_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTextEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_696_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTextEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_696_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTextEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_696_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__Eve2_696_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTextEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_696_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTextEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_696_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTextEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_696_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTextEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTextEditor", 1534, G__G__Eve2_696_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTextGL(void) {
   /* TEveTextGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTextGL));
   G__memfunc_setup("TEveTextGL",940,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTextGL), -1, 0, 1, 1, 4, 0, "u 'TEveTextGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveTextGL), -1, 1, 1, 1, 4, 0, "u 'TEveTextGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveTextGL",940,G__G__Eve2_697_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTextGL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBBox",663,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_697_0_7, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTextGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_697_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTextGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_697_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTextGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_697_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTextGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_697_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__Eve2_697_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTextGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_697_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTextGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_697_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTextGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_697_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTextGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTextGL", 1066, G__G__Eve2_697_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTrackPropagatorSubEditor(void) {
   /* TEveTrackPropagatorSubEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorSubEditor));
   G__memfunc_setup("TEveTrackPropagatorSubEditor",2841,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorSubEditor), -1, 0, 1, 1, 4, 0, "u 'TEveTrackPropagatorSubEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorSubEditor), -1, 1, 1, 1, 4, 0, "u 'TEveTrackPropagatorSubEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveTrackPropagatorSubEditor",2841,G__G__Eve2_698_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorSubEditor), -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 10 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,G__G__Eve2_698_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveTrackPropagator' - 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Changed",682,G__G__Eve2_698_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
   G__memfunc_setup("DoMaxR",555,G__G__Eve2_698_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoMaxZ",563,G__G__Eve2_698_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoMaxOrbits",1100,G__G__Eve2_698_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoMaxAng",751,G__G__Eve2_698_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoDelta",669,G__G__Eve2_698_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoFitPM",627,G__G__Eve2_698_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRnrPM",642,G__G__Eve2_698_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRnrFV",641,G__G__Eve2_698_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoModePTB",798,G__G__Eve2_698_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 0 - mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRnrPTB",715,G__G__Eve2_698_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateRefsContainer",1927,G__G__Eve2_698_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGVerticalFrame' - 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_698_0_17, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTrackPropagatorSubEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_698_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackPropagatorSubEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_698_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTrackPropagatorSubEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_698_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTrackPropagatorSubEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_698_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__Eve2_698_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackPropagatorSubEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_698_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackPropagatorSubEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_698_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackPropagatorSubEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_698_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackPropagatorSubEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTrackPropagatorSubEditor", 2967, G__G__Eve2_698_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTrack(void) {
   /* TEveTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack), -1, 1, 1, 1, 4, 0, "u 'TEveTrack' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveTrack",873,G__G__Eve2_699_0_2, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveTrack",873,G__G__Eve2_699_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack), -1, 0, 3, 1, 1, 0, 
"U 'TParticle' - 0 - t i - 'Int_t' 0 - label "
"U 'TEveTrackPropagator' - 0 '0' prop", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveTrack",873,G__G__Eve2_699_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack), -1, 0, 2, 1, 1, 0, 
"U 'TEveMCTrack' - 0 - t U 'TEveTrackPropagator' - 0 '0' prop", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveTrack",873,G__G__Eve2_699_0_5, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack), -1, 0, 2, 1, 1, 0, 
"U 'TEveRecTrack' - 0 - t U 'TEveTrackPropagator' - 0 '0' prop", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveTrack",873,G__G__Eve2_699_0_6, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack), -1, 0, 1, 1, 1, 0, "u 'TEveTrack' - 11 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetStdTitle",1113,G__G__Eve2_699_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTrackParams",1413,G__G__Eve2_699_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEveTrack' - 11 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPathMarks",1207,G__G__Eve2_699_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEveTrack' - 11 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeTrack",883,G__G__Eve2_699_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' recurse", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPropagator",1343,G__G__Eve2_699_0_12, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastPMIdx",1142,G__G__Eve2_699_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPropagator",1355,G__G__Eve2_699_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveTrackPropagator' - 0 - prop", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAttLineAttMarker",1896,G__G__Eve2_699_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveTrackList' - 0 - tl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVertex",926,G__G__Eve2_699_0_16, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR), G__defined_typename("TEveVector"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMomentum",1138,G__G__Eve2_699_0_17, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR), G__defined_typename("TEveVector"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEndMomentum",1417,G__G__Eve2_699_0_18, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR), G__defined_typename("TEveVector"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPdg",571,G__G__Eve2_699_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPdg",583,G__G__Eve2_699_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pdg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCharge",874,G__G__Eve2_699_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCharge",886,G__G__Eve2_699_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - chg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLabel",768,G__G__Eve2_699_0_23, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLabel",780,G__G__Eve2_699_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - lbl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIndex",792,G__G__Eve2_699_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIndex",804,G__G__Eve2_699_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStatus",932,G__G__Eve2_699_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStatus",944,G__G__Eve2_699_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPathMark",1057,G__G__Eve2_699_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEvePathMarkT<float>' 'TEvePathMark' 11 - pm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SortPathMarksByTime",1917,G__G__Eve2_699_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefPathMarks",1192,G__G__Eve2_699_0_31, 117, G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgR), G__defined_typename("TEveTrack::vPathMark_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefPathMarks",1192,G__G__Eve2_699_0_32, 117, G__get_linked_tagnum(&G__G__Eve2LN_vectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgR), G__defined_typename("TEveTrack::vPathMark_t"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintPathMarks",1432,G__G__Eve2_699_0_33, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetLockPoints",1330,G__G__Eve2_699_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLockPoints",1318,G__G__Eve2_699_0_35, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SecSelected",1092,G__G__Eve2_699_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveTrack' - 0 - -", "*SIGNAL*", (void*) NULL, 1);
   G__memfunc_setup("GetListTreeIcon",1493,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TGPicture), -1, 0, 1, 1, 1, 1, "g - 'Bool_t' 0 'kFALSE' open", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyVizParams",1336,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 10 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteVizParams",1448,(G__InterfaceMethod) NULL,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("ProjectedClass",1430,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 1, 1, 1, 8, "U 'TEveProjection' - 10 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShouldBreakTrack",1609,G__G__Eve2_699_0_41, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBreakProjectedTracks",2317,G__G__Eve2_699_0_42, 98, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBreakProjectedTracks",2329,G__G__Eve2_699_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 0 - bt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDefaultBreakProjectedTracks",3026,G__G__Eve2_699_0_44, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TEveTrack::GetDefaultBreakProjectedTracks) ), 0);
   G__memfunc_setup("SetDefaultBreakProjectedTracks",3038,G__G__Eve2_699_0_45, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - bt", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TEveTrack::SetDefaultBreakProjectedTracks) ), 0);
   G__memfunc_setup("Class",502,G__G__Eve2_699_0_46, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_699_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_699_0_48, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_699_0_49, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_699_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve2_699_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_699_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_699_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_699_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrack::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTrack", 999, G__G__Eve2_699_0_58, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTrackList(void) {
   /* TEveTrackList */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList));
   G__memfunc_setup("TEveTrackList",1285,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList), -1, 0, 1, 1, 4, 0, "u 'TEveTrackList' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList), -1, 1, 1, 1, 4, 0, "u 'TEveTrackList' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("FindMomentumLimits",1861,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TEveElement' - 0 - el g - 'Bool_t' 0 'kTRUE' recurse", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RoundMomentumLimit",1881,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 2, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SanitizeMinMaxCuts",1840,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveTrackList",1285,G__G__Eve2_700_0_6, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList), -1, 0, 1, 1, 1, 0, "U 'TEveTrackPropagator' - 0 '0' prop", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveTrackList",1285,G__G__Eve2_700_0_7, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackList), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name U 'TEveTrackPropagator' - 0 '0' prop", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTracks",998,G__G__Eve2_700_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' recurse", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindMomentumLimits",1861,G__G__Eve2_700_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' recurse", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPropagator",1355,G__G__Eve2_700_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveTrackPropagator' - 0 - prop", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPropagator",1343,G__G__Eve2_700_0_11, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRecurse",1017,G__G__Eve2_700_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRecurse",1029,G__G__Eve2_700_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (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 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineColor",1203,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineColor",1203,G__G__Eve2_700_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 - c U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineWidth",1204,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 - w", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineWidth",1204,G__G__Eve2_700_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Width_t' 0 - w U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineStyle",1221,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineStyle",1221,G__G__Eve2_700_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Style_t' 0 - s U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMarkerColor",1421,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - c", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMarkerColor",1421,G__G__Eve2_700_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Color_t' 0 - c U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMarkerSize",1321,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "f - 'Size_t' 0 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMarkerSize",1321,G__G__Eve2_700_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Size_t' 0 - s U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMarkerStyle",1439,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMarkerStyle",1439,G__G__Eve2_700_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
"s - 'Style_t' 0 - s U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRnrLine",998,G__G__Eve2_700_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - rnr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRnrLine",998,G__G__Eve2_700_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - rnr U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRnrLine",986,G__G__Eve2_700_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRnrPoints",1243,G__G__Eve2_700_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRnrPoints",1243,G__G__Eve2_700_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - r U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRnrPoints",1231,G__G__Eve2_700_0_32, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectByPt",991,G__G__Eve2_700_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - min_pt f - 'Float_t' 0 - max_pt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectByPt",991,G__G__Eve2_700_0_34, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - min_pt f - 'Float_t' 0 - max_pt "
"U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectByP",875,G__G__Eve2_700_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - min_p f - 'Float_t' 0 - max_p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectByP",875,G__G__Eve2_700_0_36, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - min_p f - 'Float_t' 0 - max_p "
"U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinPt",776,G__G__Eve2_700_0_37, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxPt",778,G__G__Eve2_700_0_38, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLimPt",774,G__G__Eve2_700_0_39, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinP",660,G__G__Eve2_700_0_40, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxP",662,G__G__Eve2_700_0_41, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLimP",658,G__G__Eve2_700_0_42, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindTrackByLabel",1553,G__G__Eve2_700_0_43, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - label", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("FindTrackByIndex",1577,G__G__Eve2_700_0_44, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrack), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("CopyVizParams",1336,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveElement' - 10 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteVizParams",1448,(G__InterfaceMethod) NULL,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("ProjectedClass",1430,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 1, 1, 1, 8, "U 'TEveProjection' - 10 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_700_0_48, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTrackList::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_700_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackList::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_700_0_50, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTrackList::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_700_0_51, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTrackList::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_700_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve2_700_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackList::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_700_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackList::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_700_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackList::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_700_0_59, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackList::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTrackList", 1411, G__G__Eve2_700_0_60, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTrackEditor(void) {
   /* TEveTrackEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackEditor));
   G__memfunc_setup("TEveTrackEditor",1488,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackEditor), -1, 0, 1, 1, 4, 0, "u 'TEveTrackEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackEditor), -1, 1, 1, 1, 4, 0, "u 'TEveTrackEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveTrackEditor",1488,G__G__Eve2_701_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackEditor), -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("DoEditPropagator",1624,G__G__Eve2_701_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_701_0_6, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTrackEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_701_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_701_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTrackEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_701_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTrackEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_701_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__Eve2_701_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_701_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_701_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_701_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTrackEditor", 1614, G__G__Eve2_701_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTrackListEditor(void) {
   /* TEveTrackListEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListEditor));
   G__memfunc_setup("TEveTrackListEditor",1900,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListEditor), -1, 0, 1, 1, 4, 0, "u 'TEveTrackListEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListEditor), -1, 1, 1, 1, 4, 0, "u 'TEveTrackListEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("CreateRefTab",1160,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveTrackListEditor",1900,G__G__Eve2_702_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListEditor), -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("CreateRefsTab",1275,G__G__Eve2_702_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (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("DoRnrLine",877,G__G__Eve2_702_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRnrPoints",1122,G__G__Eve2_702_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPtRange",868,G__G__Eve2_702_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoPRange",752,G__G__Eve2_702_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_702_0_11, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTrackListEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_702_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackListEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_702_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTrackListEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_702_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTrackListEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_702_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__Eve2_702_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackListEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_702_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackListEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_702_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackListEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_702_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackListEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTrackListEditor", 2026, G__G__Eve2_702_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTrackGL(void) {
   /* TEveTrackGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackGL));
   G__memfunc_setup("TEveTrackGL",1020,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackGL), -1, 0, 1, 1, 4, 0, "u 'TEveTrackGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackGL), -1, 1, 1, 1, 4, 0, "u 'TEveTrackGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("RenderPathMarksAndFirstVertex",2948,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveTrackGL",1020,G__G__Eve2_703_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackGL), -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("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("SupportsSecondarySelect",2424,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessSelection",1669,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TGLRnrCtx' - 1 - rnrCtx u 'TGLSelectRecord' - 1 - rec", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_703_0_9, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTrackGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_703_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_703_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTrackGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_703_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTrackGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_703_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__Eve2_703_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_703_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_703_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_703_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTrackGL", 1146, G__G__Eve2_703_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTrackPropagator(void) {
   /* TEveTrackPropagator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator));
   G__memfunc_setup("TEveTrackPropagator",1928,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator), -1, 0, 1, 1, 4, 0, "u 'TEveTrackPropagator' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator), -1, 1, 1, 1, 4, 0, "u 'TEveTrackPropagator' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("RebuildTracks",1327,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Update",611,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"u 'TEveVector4T<float>' 'TEveVector4' 11 - v u 'TEveVectorT<float>' 'TEveVector' 11 - p "
"g - 'Bool_t' 0 'kFALSE' full_update g - 'Bool_t' 0 'kFALSE' enforce_max_step", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Step",412,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"u 'TEveVector4T<float>' 'TEveVector4' 11 - v u 'TEveVectorT<float>' 'TEveVector' 11 - p "
"u 'TEveVector4T<float>' 'TEveVector4' 1 - vOut u 'TEveVectorT<float>' 'TEveVector' 1 - pOut", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoopToVertex",1243,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"u 'TEveVectorT<float>' 'TEveVector' 1 - v u 'TEveVectorT<float>' 'TEveVector' 1 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoopToBounds",1224,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TEveVectorT<float>' 'TEveVector' 1 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LineToVertex",1225,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "u 'TEveVectorT<float>' 'TEveVector' 1 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LineToBounds",1206,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TEveVectorT<float>' 'TEveVector' 1 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StepRungeKutta",1446,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"d - 'Double_t' 0 - step D - 'Double_t' 0 - vect "
"D - 'Double_t' 0 - vout", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HelixIntersectPlane",1947,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 2, 0, 
"u 'TEveVectorT<float>' 'TEveVector' 11 - p u 'TEveVectorT<float>' 'TEveVector' 11 - point "
"u 'TEveVectorT<float>' 'TEveVector' 11 - normal u 'TEveVectorT<float>' 'TEveVector' 1 - itsect", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LineIntersectPlane",1833,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 2, 0, 
"u 'TEveVectorT<float>' 'TEveVector' 11 - p u 'TEveVectorT<float>' 'TEveVector' 11 - point "
"u 'TEveVectorT<float>' 'TEveVector' 11 - normal u 'TEveVectorT<float>' 'TEveVector' 1 - itsect", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PointOverVertex",1572,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 2, 0, 
"u 'TEveVector4T<float>' 'TEveVector4' 11 - v0 u 'TEveVector4T<float>' 'TEveVector4' 11 - v "
"F - 'Float_t' 0 '0' p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveTrackPropagator",1928,G__G__Eve2_710_0_14, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagator), -1, 0, 4, 1, 1, 0, 
"C - - 10 '\"TEveTrackPropagator\"' n C - - 10 '\"\"' t "
"U 'TEveMagField' - 0 '0' field g - 'Bool_t' 0 'kTRUE' own_field", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OnZeroRefCount",1411,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckReferenceCount",1910,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TEveException' - 11 '\"TEveElement::CheckReferenceCount \"' eh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ElementChanged",1396,(G__InterfaceMethod) NULL,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("InitTrack",905,G__G__Eve2_710_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TEveVectorT<float>' 'TEveVector' 1 - v i - 'Int_t' 0 - charge", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetTrack",1016,G__G__Eve2_710_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GoToBounds",996,G__G__Eve2_710_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEveVectorT<float>' 'TEveVector' 1 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GoToVertex",1015,G__G__Eve2_710_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TEveVectorT<float>' 'TEveVector' 1 - v u 'TEveVectorT<float>' 'TEveVector' 1 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntersectPlane",1441,G__G__Eve2_710_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"u 'TEveVectorT<float>' 'TEveVector' 11 - p u 'TEveVectorT<float>' 'TEveVector' 11 - point "
"u 'TEveVectorT<float>' 'TEveVector' 11 - normal u 'TEveVectorT<float>' 'TEveVector' 1 - itsect", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillPointSet",1213,G__G__Eve2_710_0_23, 121, -1, -1, 0, 1, 1, 1, 8, "U 'TEvePointSet' - 0 - ps", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStepper",1039,G__G__Eve2_710_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TEveTrackPropagator::EStepper_e' - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMagField",1061,G__G__Eve2_710_0_25, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - bX f - 'Float_t' 0 - bY "
"f - 'Float_t' 0 - bZ", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMagField",1061,G__G__Eve2_710_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMagFieldObj",1344,G__G__Eve2_710_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveMagField' - 0 - field g - 'Bool_t' 0 'kTRUE' own_field", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxR",676,G__G__Eve2_710_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxZ",684,G__G__Eve2_710_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxOrbs",1000,G__G__Eve2_710_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinAng",870,G__G__Eve2_710_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxAng",872,G__G__Eve2_710_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxStep",1006,G__G__Eve2_710_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDelta",790,G__G__Eve2_710_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEditPathMarks",1597,G__G__Eve2_710_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRnrDaughters",1541,G__G__Eve2_710_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRnrReferences",1632,G__G__Eve2_710_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRnrDecay",1092,G__G__Eve2_710_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRnrCluster2Ds",1577,G__G__Eve2_710_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFitDaughters",1526,G__G__Eve2_710_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFitReferences",1617,G__G__Eve2_710_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFitDecay",1077,G__G__Eve2_710_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFitCluster2Ds",1562,G__G__Eve2_710_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRnrFV",762,G__G__Eve2_710_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProjTrackBreaking",2015,G__G__Eve2_710_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "b - 'UChar_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRnrPTBMarkers",1561,G__G__Eve2_710_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMagField",1049,G__G__Eve2_710_0_47, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR), G__defined_typename("TEveVector"), 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("PrintMagField",1286,G__G__Eve2_710_0_48, 121, -1, -1, 0, 3, 1, 1, 8, 
"f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
"f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStepper",1027,G__G__Eve2_710_0_49, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorcLcLEStepper_e), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxR",664,G__G__Eve2_710_0_50, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxZ",672,G__G__Eve2_710_0_51, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxOrbs",988,G__G__Eve2_710_0_52, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinAng",858,G__G__Eve2_710_0_53, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxAng",860,G__G__Eve2_710_0_54, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxStep",994,G__G__Eve2_710_0_55, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDelta",778,G__G__Eve2_710_0_56, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEditPathMarks",1585,G__G__Eve2_710_0_57, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRnrDaughters",1529,G__G__Eve2_710_0_58, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRnrReferences",1620,G__G__Eve2_710_0_59, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRnrDecay",1080,G__G__Eve2_710_0_60, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRnrCluster2Ds",1565,G__G__Eve2_710_0_61, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitDaughters",1514,G__G__Eve2_710_0_62, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitReferences",1605,G__G__Eve2_710_0_63, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitDecay",1065,G__G__Eve2_710_0_64, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitCluster2Ds",1550,G__G__Eve2_710_0_65, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRnrFV",750,G__G__Eve2_710_0_66, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProjTrackBreaking",2003,G__G__Eve2_710_0_67, 98, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRnrPTBMarkers",1549,G__G__Eve2_710_0_68, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefPMAtt",739,G__G__Eve2_710_0_69, 117, G__get_linked_tagnum(&G__G__Eve2LN_TMarker), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefFVAtt",738,G__G__Eve2_710_0_70, 117, G__get_linked_tagnum(&G__G__Eve2LN_TMarker), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefPTBAtt",812,G__G__Eve2_710_0_71, 117, G__get_linked_tagnum(&G__G__Eve2LN_TMarker), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOutsideBounds",1540,G__G__Eve2_710_0_72, 103, -1, G__defined_typename("Bool_t"), 0, 3, 3, 1, 0, 
"u 'TEveVectorT<float>' 'TEveVector' 11 - point f - 'Float_t' 0 - maxRsqr "
"f - 'Float_t' 0 - maxZ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const TEveVector&, Float_t, Float_t))(&TEveTrackPropagator::IsOutsideBounds) ), 0);
   G__memfunc_setup("Class",502,G__G__Eve2_710_0_73, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTrackPropagator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_710_0_74, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackPropagator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_710_0_75, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTrackPropagator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_710_0_76, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTrackPropagator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_710_0_80, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve2_710_0_81, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackPropagator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_710_0_82, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackPropagator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_710_0_83, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackPropagator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_710_0_84, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackPropagator::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTrackPropagator", 2054, G__G__Eve2_710_0_85, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTrackProjected(void) {
   /* TEveTrackProjected */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected));
   G__memfunc_setup("TEveTrackProjected",1801,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected), -1, 0, 1, 1, 4, 0, "u 'TEveTrackProjected' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected), -1, 1, 1, 1, 4, 0, "u 'TEveTrackProjected' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("GetBreakPointIdx",1588,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "i - 'Int_t' 0 - start", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBreakPoint",1295,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 4, 0, 
"i - 'Int_t' 0 - N g - 'Bool_t' 0 - back "
"f - 'Float_t' 1 - x f - 'Float_t' 1 - y "
"f - 'Float_t' 1 - z", (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("TEveTrackProjected",1801,G__G__Eve2_719_0_6, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjected), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProjection",1353,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveProjectionManager' - 0 - mng U 'TEveProjectable' - 0 - model", (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__Eve2LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeTrack",883,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' recurse", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintLineSegments",1755,G__G__Eve2_719_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SecSelected",1092,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEveTrack' - 0 - -", "marked as signal in TEveTrack", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_719_0_13, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTrackProjected::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_719_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackProjected::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_719_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTrackProjected::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_719_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTrackProjected::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_719_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__Eve2_719_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackProjected::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_719_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackProjected::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_719_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackProjected::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_719_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackProjected::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTrackProjected", 1927, G__G__Eve2_719_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTrackProjectedGL(void) {
   /* TEveTrackProjectedGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjectedGL));
   G__memfunc_setup("TEveTrackProjectedGL",1948,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjectedGL), -1, 0, 1, 1, 4, 0, "u 'TEveTrackProjectedGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjectedGL), -1, 1, 1, 1, 4, 0, "u 'TEveTrackProjectedGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveTrackProjectedGL",1948,G__G__Eve2_720_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackProjectedGL), -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("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_720_0_6, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTrackProjectedGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_720_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackProjectedGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_720_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTrackProjectedGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_720_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTrackProjectedGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_720_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__Eve2_720_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackProjectedGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_720_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackProjectedGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_720_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackProjectedGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_720_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackProjectedGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTrackProjectedGL", 2074, G__G__Eve2_720_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTrackListProjected(void) {
   /* TEveTrackListProjected */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListProjected));
   G__memfunc_setup("TEveTrackListProjected",2213,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListProjected), -1, 0, 1, 1, 4, 0, "u 'TEveTrackListProjected' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListProjected), -1, 1, 1, 1, 4, 0, "u 'TEveTrackListProjected' - 11 - -", "Not implemented", (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("TEveTrackListProjected",2213,G__G__Eve2_721_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackListProjected), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetProjection",1353,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveProjectionManager' - 0 - proj U 'TEveProjectable' - 0 - model", (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__Eve2LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDepth",801,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - d", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDepth",801,G__G__Eve2_721_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - d U 'TEveElement' - 0 - el", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_721_0_10, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTrackListProjected::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_721_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackListProjected::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_721_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTrackListProjected::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_721_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTrackListProjected::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_721_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__Eve2_721_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackListProjected::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_721_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackListProjected::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_721_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackListProjected::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_721_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackListProjected::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTrackListProjected", 2339, G__G__Eve2_721_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTrackPropagatorEditor(void) {
   /* TEveTrackPropagatorEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorEditor));
   G__memfunc_setup("TEveTrackPropagatorEditor",2543,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorEditor), -1, 0, 1, 1, 4, 0, "u 'TEveTrackPropagatorEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorEditor), -1, 1, 1, 1, 4, 0, "u 'TEveTrackPropagatorEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("CreateRefTab",1160,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveTrackPropagatorEditor",2543,G__G__Eve2_725_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTrackPropagatorEditor), -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__Eve2_725_0_6, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTrackPropagatorEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_725_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackPropagatorEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_725_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTrackPropagatorEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_725_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTrackPropagatorEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_725_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__Eve2_725_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackPropagatorEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_725_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackPropagatorEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_725_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTrackPropagatorEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_725_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTrackPropagatorEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTrackPropagatorEditor", 2669, G__G__Eve2_725_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveMagField(void) {
   /* TEveMagField */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveMagField));
   G__memfunc_setup("IsConst",707,G__G__Eve2_726_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintField",1009,G__G__Eve2_726_0_3, 121, -1, -1, 0, 3, 1, 1, 8, 
"f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
"f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetField",772,G__G__Eve2_726_0_4, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR), G__defined_typename("TEveVector"), 0, 1, 1, 1, 8, "u 'TEveVectorT<float>' 'TEveVector' 11 - v", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetField",772,G__G__Eve2_726_0_5, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR), G__defined_typename("TEveVector"), 0, 3, 1, 1, 8, 
"f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
"f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMaxFieldMag",1343,G__G__Eve2_726_0_6, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", "not abstract because of backward compatibility", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_726_0_7, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveMagField::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_726_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMagField::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_726_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveMagField::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_726_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveMagField::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Eve2_726_0_11, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Eve2_726_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__Eve2_726_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__Eve2_726_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__Eve2_726_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMagField::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_726_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveMagField::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_726_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMagField::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_726_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveMagField::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveMagField", 1259, G__G__Eve2_726_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__Eve2_726_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__Eve2LN_TEveMagField), -1, 1, 1, 1, 1, 0, "u 'TEveMagField' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveMagFieldConst(void) {
   /* TEveMagFieldConst */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldConst));
   G__memfunc_setup("TEveMagFieldConst",1652,G__G__Eve2_727_0_1, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldConst), -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("GetField",772,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR), G__defined_typename("TEveVector"), 0, 3, 1, 1, 8, 
"f - 'Float_t' 0 - - f - 'Float_t' 0 - - "
"f - 'Float_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaxFieldMag",1343,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_727_0_4, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveMagFieldConst::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_727_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMagFieldConst::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_727_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveMagFieldConst::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_727_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveMagFieldConst::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_727_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__Eve2_727_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMagFieldConst::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_727_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveMagFieldConst::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_727_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMagFieldConst::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_727_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveMagFieldConst::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEveMagFieldConst", 1652, G__G__Eve2_727_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldConst), -1, 0, 1, 1, 1, 0, "u 'TEveMagFieldConst' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveMagFieldConst", 1778, G__G__Eve2_727_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__Eve2_727_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldConst), -1, 1, 1, 1, 1, 0, "u 'TEveMagFieldConst' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveMagFieldDuo(void) {
   /* TEveMagFieldDuo */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldDuo));
   G__memfunc_setup("TEveMagFieldDuo",1429,G__G__Eve2_728_0_1, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldDuo), -1, 0, 3, 1, 1, 0, 
"f - 'Float_t' 0 - r f - 'Float_t' 0 - bIn "
"f - 'Float_t' 0 - bOut", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetField",772,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR), G__defined_typename("TEveVector"), 0, 3, 1, 1, 8, 
"f - 'Float_t' 0 - x f - 'Float_t' 0 - y "
"f - 'Float_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaxFieldMag",1343,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_728_0_4, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveMagFieldDuo::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_728_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMagFieldDuo::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_728_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveMagFieldDuo::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_728_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveMagFieldDuo::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_728_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__Eve2_728_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMagFieldDuo::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_728_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveMagFieldDuo::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_728_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveMagFieldDuo::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_728_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveMagFieldDuo::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TEveMagFieldDuo", 1429, G__G__Eve2_728_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldDuo), -1, 0, 1, 1, 1, 0, "u 'TEveMagFieldDuo' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TEveMagFieldDuo", 1555, G__G__Eve2_728_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__Eve2_728_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__Eve2LN_TEveMagFieldDuo), -1, 1, 1, 1, 1, 0, "u 'TEveMagFieldDuo' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTriangleSet(void) {
   /* TEveTriangleSet */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSet));
   G__memfunc_setup("TEveTriangleSet",1494,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSet), -1, 0, 1, 1, 4, 0, "u 'TEveTriangleSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSet), -1, 1, 1, 1, 4, 0, "u 'TEveTriangleSet' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveTriangleSet",1494,G__G__Eve2_736_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSet), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - nv i - 'Int_t' 0 - nt "
"g - 'Bool_t' 0 'kFALSE' norms g - 'Bool_t' 0 'kFALSE' cols", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CanEditMainTransparency",2327,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNVerts",898,G__G__Eve2_736_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNTrings",997,G__G__Eve2_736_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Vertex",638,G__G__Eve2_736_0_7, 70, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Triangle",822,G__G__Eve2_736_0_8, 73, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TriangleNormal",1439,G__G__Eve2_736_0_9, 70, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TriangleColor",1333,G__G__Eve2_736_0_10, 66, -1, G__defined_typename("UChar_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVertex",938,G__G__Eve2_736_0_11, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - i f - 'Float_t' 0 - x "
"f - 'Float_t' 0 - y f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTriangle",1122,G__G__Eve2_736_0_12, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - v0 "
"i - 'Int_t' 0 - v1 i - 'Int_t' 0 - v2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTriangleColor",1633,G__G__Eve2_736_0_13, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - i b - 'UChar_t' 0 - r "
"b - 'UChar_t' 0 - g b - 'UChar_t' 0 - b "
"b - 'UChar_t' 0 '255' a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateTriangleNormals",2365,G__G__Eve2_736_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateRandomColors",2046,G__G__Eve2_736_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateZNormalColors",2144,G__G__Eve2_736_0_16, 121, -1, -1, 0, 5, 1, 1, 0, 
"f - 'Float_t' 0 '20' fac i - 'Int_t' 0 '-20' min "
"i - 'Int_t' 0 '20' max g - 'Bool_t' 0 'kFALSE' interp "
"g - 'Bool_t' 0 'kFALSE' wrap", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (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("SetTransparency",1574,G__G__Eve2_736_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 - tr", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("ReadTrivialFile",1495,G__G__Eve2_736_0_20, 85, G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSet), -1, 0, 1, 3, 1, 0, "C - - 10 - file", (char*)NULL, (void*) G__func2void( (TEveTriangleSet* (*)(const char*))(&TEveTriangleSet::ReadTrivialFile) ), 0);
   G__memfunc_setup("Class",502,G__G__Eve2_736_0_21, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTriangleSet::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_736_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTriangleSet::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_736_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTriangleSet::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_736_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTriangleSet::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_736_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__Eve2_736_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTriangleSet::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_736_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTriangleSet::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_736_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTriangleSet::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_736_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTriangleSet::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTriangleSet", 1620, G__G__Eve2_736_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTriangleSetEditor(void) {
   /* TEveTriangleSetEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetEditor));
   G__memfunc_setup("TEveTriangleSetEditor",2109,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetEditor), -1, 0, 1, 1, 4, 0, "u 'TEveTriangleSetEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetEditor), -1, 1, 1, 1, 4, 0, "u 'TEveTriangleSetEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveTriangleSetEditor",2109,G__G__Eve2_737_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetEditor), -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__Eve2_737_0_5, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTriangleSetEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_737_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTriangleSetEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_737_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTriangleSetEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_737_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTriangleSetEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_737_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__Eve2_737_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTriangleSetEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_737_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTriangleSetEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_737_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTriangleSetEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_737_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTriangleSetEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTriangleSetEditor", 2235, G__G__Eve2_737_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveTriangleSetGL(void) {
   /* TEveTriangleSetGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetGL));
   G__memfunc_setup("TEveTriangleSetGL",1641,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetGL), -1, 0, 1, 1, 4, 0, "u 'TEveTriangleSetGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetGL), -1, 1, 1, 1, 4, 0, "u 'TEveTriangleSetGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveTriangleSetGL",1641,G__G__Eve2_738_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveTriangleSetGL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBBox",663,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_738_0_7, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveTriangleSetGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_738_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTriangleSetGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_738_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveTriangleSetGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_738_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveTriangleSetGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_738_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Eve2_738_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTriangleSetGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_738_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTriangleSetGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_738_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveTriangleSetGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_738_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveTriangleSetGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveTriangleSetGL", 1767, G__G__Eve2_738_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveJetCone(void) {
   /* TEveJetCone */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetCone));
   G__memfunc_setup("TEveJetCone",1052,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveJetCone), -1, 0, 1, 1, 4, 0, "u 'TEveJetCone' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveJetCone), -1, 1, 1, 1, 4, 0, "u 'TEveJetCone' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("CalcEtaPhiVec",1228,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR), G__defined_typename("TEveVector"), 0, 2, 1, 2, 8, 
"f - 'Float_t' 0 - eta f - 'Float_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcBaseVec",1036,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR), G__defined_typename("TEveVector"), 0, 2, 1, 2, 8, 
"f - 'Float_t' 0 - eta f - 'Float_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcBaseVec",1036,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveVectorTlEfloatgR), G__defined_typename("TEveVector"), 0, 1, 1, 2, 8, "f - 'Float_t' 0 - alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInTransitionRegion",2050,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveJetCone",1052,G__G__Eve2_739_0_7, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveJetCone), -1, 0, 2, 1, 1, 0, 
"C - 'Text_t' 10 '\"TEveJetCone\"' n C - 'Text_t' 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProjectedClass",1430,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 1, 1, 1, 8, "U 'TEveProjection' - 10 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetApex",698,G__G__Eve2_739_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TEveVectorT<float>' 'TEveVector' 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCylinder",1126,G__G__Eve2_739_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - r f - 'Float_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRadius",916,G__G__Eve2_739_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNDiv",657,G__G__Eve2_739_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNDiv",669,G__G__Eve2_739_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddCone",654,G__G__Eve2_739_0_15, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
"f - 'Float_t' 0 - eta f - 'Float_t' 0 - phi "
"f - 'Float_t' 0 - cone_r f - 'Float_t' 0 '0' length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddEllipticCone",1476,G__G__Eve2_739_0_16, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"f - 'Float_t' 0 - eta f - 'Float_t' 0 - phi "
"f - 'Float_t' 0 - reta f - 'Float_t' 0 - rphi "
"f - 'Float_t' 0 '0' length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Eve2_739_0_17, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveJetCone::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_739_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveJetCone::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_739_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveJetCone::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_739_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveJetCone::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_739_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__Eve2_739_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveJetCone::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_739_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveJetCone::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_739_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveJetCone::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_739_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveJetCone::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveJetCone", 1178, G__G__Eve2_739_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveJetConeEditor(void) {
   /* TEveJetConeEditor */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeEditor));
   G__memfunc_setup("TEveJetConeEditor",1667,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeEditor), -1, 0, 1, 1, 4, 0, "u 'TEveJetConeEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeEditor), -1, 1, 1, 1, 4, 0, "u 'TEveJetConeEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEveJetConeEditor",1667,G__G__Eve2_740_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeEditor), -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__Eve2_740_0_5, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveJetConeEditor::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_740_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveJetConeEditor::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_740_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveJetConeEditor::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_740_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveJetConeEditor::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_740_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__Eve2_740_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveJetConeEditor::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_740_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveJetConeEditor::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_740_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveJetConeEditor::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_740_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveJetConeEditor::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveJetConeEditor", 1793, G__G__Eve2_740_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveJetConeProjected(void) {
   /* TEveJetConeProjected */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjected));
   G__memfunc_setup("TEveJetConeProjected",1980,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjected), -1, 0, 1, 1, 4, 0, "u 'TEveJetConeProjected' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjected), -1, 1, 1, 1, 4, 0, "u 'TEveJetConeProjected' - 11 - -", "Not implemented", (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("TEveJetConeProjected",1980,G__G__Eve2_741_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjected), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEveJetConeProjected\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetProjection",1353,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TEveProjectionManager' - 0 - mng U 'TEveProjectable' - 0 - model", (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__Eve2LN_TEveElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_741_0_9, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveJetConeProjected::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_741_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveJetConeProjected::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_741_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveJetConeProjected::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_741_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveJetConeProjected::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_741_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__Eve2_741_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveJetConeProjected::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_741_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveJetConeProjected::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_741_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveJetConeProjected::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_741_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveJetConeProjected::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveJetConeProjected", 2106, G__G__Eve2_741_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveJetConeGL(void) {
   /* TEveJetConeGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeGL));
   G__memfunc_setup("TEveJetConeGL",1199,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeGL), -1, 0, 1, 1, 4, 0, "u 'TEveJetConeGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeGL), -1, 1, 1, 1, 4, 0, "u 'TEveJetConeGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("CalculatePoints",1547,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TEveJetConeGL",1199,G__G__Eve2_742_0_4, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeGL), -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("DLCacheClear",1099,(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("Class",502,G__G__Eve2_742_0_10, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveJetConeGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_742_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveJetConeGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_742_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveJetConeGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_742_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveJetConeGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_742_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__Eve2_742_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveJetConeGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_742_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveJetConeGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_742_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveJetConeGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_742_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveJetConeGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveJetConeGL", 1325, G__G__Eve2_742_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEveJetConeProjectedGL(void) {
   /* TEveJetConeProjectedGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjectedGL));
   G__memfunc_setup("TEveJetConeProjectedGL",2127,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjectedGL), -1, 0, 1, 1, 4, 0, "u 'TEveJetConeProjectedGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjectedGL), -1, 1, 1, 1, 4, 0, "u 'TEveJetConeProjectedGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("CalculatePoints",1547,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RenderOutline",1344,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RenderPolygon",1352,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TEveJetConeProjectedGL",2127,G__G__Eve2_747_0_6, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEveJetConeProjectedGL), -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("Class",502,G__G__Eve2_747_0_11, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEveJetConeProjectedGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_747_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveJetConeProjectedGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_747_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEveJetConeProjectedGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_747_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEveJetConeProjectedGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_747_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__Eve2_747_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveJetConeProjectedGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_747_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveJetConeProjectedGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_747_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEveJetConeProjectedGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_747_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEveJetConeProjectedGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEveJetConeProjectedGL", 2253, G__G__Eve2_747_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvePlot3D(void) {
   /* TEvePlot3D */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3D));
   G__memfunc_setup("TEvePlot3D",906,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3D), -1, 0, 1, 1, 4, 0, "u 'TEvePlot3D' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3D), -1, 1, 1, 1, 4, 0, "u 'TEvePlot3D' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEvePlot3D",906,G__G__Eve2_748_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3D), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"TEvePlot3D\"' n C - - 10 '\"\"' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPlot",715,G__G__Eve2_748_0_4, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj u 'TString' - 11 - opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlot",703,G__G__Eve2_748_0_5, 85, G__get_linked_tagnum(&G__G__Eve2LN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlotOption",1336,G__G__Eve2_748_0_6, 117, G__get_linked_tagnum(&G__G__Eve2LN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLogXYZ",857,G__G__Eve2_748_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"g - 'Bool_t' 0 - lx g - 'Bool_t' 0 - ly "
"g - 'Bool_t' 0 - lz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLogX",678,G__G__Eve2_748_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLogY",679,G__G__Eve2_748_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLogZ",680,G__G__Eve2_748_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLogX",666,G__G__Eve2_748_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLogY",667,G__G__Eve2_748_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLogZ",668,G__G__Eve2_748_0_13, 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("Class",502,G__G__Eve2_748_0_15, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvePlot3D::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_748_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePlot3D::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_748_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvePlot3D::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_748_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvePlot3D::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_748_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__Eve2_748_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePlot3D::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_748_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePlot3D::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_748_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePlot3D::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_748_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePlot3D::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEvePlot3D", 1032, G__G__Eve2_748_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTEvePlot3DGL(void) {
   /* TEvePlot3DGL */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3DGL));
   G__memfunc_setup("TEvePlot3DGL",1053,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3DGL), -1, 0, 1, 1, 4, 0, "u 'TEvePlot3DGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3DGL), -1, 1, 1, 1, 4, 0, "u 'TEvePlot3DGL' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("TEvePlot3DGL",1053,G__G__Eve2_750_0_3, 105, G__get_linked_tagnum(&G__G__Eve2LN_TEvePlot3DGL), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("KeepDuringSmartRefresh",2244,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBBox",663,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DirectDraw",1001,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TGLRnrCtx' - 1 - rnrCtx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Eve2_750_0_8, 85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEvePlot3DGL::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Eve2_750_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePlot3DGL::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Eve2_750_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEvePlot3DGL::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Eve2_750_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEvePlot3DGL::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Eve2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Eve2_750_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__Eve2_750_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePlot3DGL::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Eve2_750_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePlot3DGL::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Eve2_750_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEvePlot3DGL::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Eve2_750_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEvePlot3DGL::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TEvePlot3DGL", 1179, G__G__Eve2_750_0_20, (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__Eve2() {
}

/*********************************************************
* 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__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Eve2() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
  G__cpp_setup_global4();
  G__cpp_setup_global5();
  G__cpp_setup_global6();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {
}

static void G__cpp_setup_func7() {
}

static void G__cpp_setup_func8() {
}

static void G__cpp_setup_func9() {
}

static void G__cpp_setup_func10() {
}

static void G__cpp_setup_func11() {
}

static void G__cpp_setup_func12() {
}

static void G__cpp_setup_func13() {
}

static void G__cpp_setup_func14() {
}

static void G__cpp_setup_func15() {
}

static void G__cpp_setup_func16() {
}

static void G__cpp_setup_func17() {
}

static void G__cpp_setup_func18() {
}

static void G__cpp_setup_func19() {
}

static void G__cpp_setup_func20() {
}

static void G__cpp_setup_func21() {
}

static void G__cpp_setup_func22() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Eve2() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
  G__cpp_setup_func6();
  G__cpp_setup_func7();
  G__cpp_setup_func8();
  G__cpp_setup_func9();
  G__cpp_setup_func10();
  G__cpp_setup_func11();
  G__cpp_setup_func12();
  G__cpp_setup_func13();
  G__cpp_setup_func14();
  G__cpp_setup_func15();
  G__cpp_setup_func16();
  G__cpp_setup_func17();
  G__cpp_setup_func18();
  G__cpp_setup_func19();
  G__cpp_setup_func20();
  G__cpp_setup_func21();
  G__cpp_setup_func22();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__Eve2LN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_Event_t = { "Event_t" , 115 , -1 };
G__linked_taginfo G__G__Eve2LN_TGObject = { "TGObject" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TQObject = { "TQObject" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGWindow = { "TGWindow" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGPicture = { "TGPicture" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TAttLine = { "TAttLine" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TAttMarker = { "TAttMarker" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGFrame = { "TGFrame" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGCompositeFrame = { "TGCompositeFrame" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__Eve2LN_TGTextButton = { "TGTextButton" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGVerticalFrame = { "TGVerticalFrame" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGHorizontalFrame = { "TGHorizontalFrame" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGLabel = { "TGLabel" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGedFrame = { "TGedFrame" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveGValuator = { "TEveGValuator" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveArrow = { "TEveArrow" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveGTriVecValuator = { "TEveGTriVecValuator" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveArrowEditor = { "TEveArrowEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR = { "vector<TGLPlane,allocator<TGLPlane> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlETGLPlanecOallocatorlETGLPlanegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TGLPlane,allocator<TGLPlane> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_pairlEboolcOTGLLine3gR = { "pair<bool,TGLLine3>" , 115 , -1 };
G__linked_taginfo G__G__Eve2LN_pairlEboolcOTGLVertex3gR = { "pair<bool,TGLVertex3>" , 115 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR = { "vector<unsigned char,allocator<unsigned char> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned char,allocator<unsigned char> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TAxis = { "TAxis" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_pairlEintcOintgR = { "pair<int,int>" , 115 , -1 };
G__linked_taginfo G__G__Eve2LN_pairlEdoublecOdoublegR = { "pair<double,double>" , 115 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<double,allocator<double> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TBuffer3D = { "TBuffer3D" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGLPhysicalShape = { "TGLPhysicalShape" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGLRnrCtx = { "TGLRnrCtx" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGLSelectRecord = { "TGLSelectRecord" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGLLogicalShape = { "TGLLogicalShape" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGLObject = { "TGLObject" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveArrowGL = { "TEveArrowGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGeoManager = { "TGeoManager" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveElement = { "TEveElement" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveException = { "TEveException" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveRefCnt = { "TEveRefCnt" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveRefBackPtr = { "TEveRefBackPtr" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgR = { "map<TEveElement*,int,less<TEveElement*>,allocator<pair<TEveElement* const,int> > >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveProjection = { "TEveProjection" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveProjected = { "TEveProjected" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveProjectionManager = { "TEveProjectionManager" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveProjectable = { "TEveProjectable" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_listlETEveProjectedmUcOallocatorlETEveProjectedmUgRsPgR = { "list<TEveProjected*,allocator<TEveProjected*> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR = { "set<TEveElement*,less<TEveElement*>,allocator<TEveElement*> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGListTree = { "TGListTree" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGListTreeItem = { "TGListTreeItem" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTrans = { "TEveTrans" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgR = { "set<TEveElement::TEveListTreeInfo,less<TEveElement::TEveListTreeInfo>,allocator<TEveElement::TEveListTreeInfo> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR = { "list<TEveElement*,allocator<TEveElement*> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveElementList = { "TEveElementList" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveVectorTlEfloatgR = { "TEveVectorT<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveVectorTlEdoublegR = { "TEveVectorT<double>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveVector4TlEfloatgR = { "TEveVector4T<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveVector4TlEdoublegR = { "TEveVector4T<double>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveVector2TlEfloatgR = { "TEveVector2T<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveVector2TlEdoublegR = { "TEveVector2T<double>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TAtt3D = { "TAtt3D" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TAttBBox = { "TAttBBox" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveBox = { "TEveBox" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveBoxProjected = { "TEveBoxProjected" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveBoxGL = { "TEveBoxGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveBoxProjectedGL = { "TEveBoxProjectedGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TArrayI = { "TArrayI" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveShape = { "TEveShape" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveShapeEditor = { "TEveShapeEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgR = { "vector<TEveVector2T<float>,allocator<TEveVector2T<float> > >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgRcLcLiterator = { "vector<TEveVector2T<float>,allocator<TEveVector2T<float> > >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TEveVector2T<float>,allocator<TEveVector2T<float> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveFrameBox = { "TEveFrameBox" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveFrameBoxGL = { "TEveFrameBoxGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveFrameBoxcLcLEFrameType_e = { "TEveFrameBox::EFrameType_e" , 101 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveRGBAPalette = { "TEveRGBAPalette" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveRGBAPaletteEditor = { "TEveRGBAPaletteEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveRGBAPaletteSubEditor = { "TEveRGBAPaletteSubEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveRGBAPalettecLcLELimitAction_e = { "TEveRGBAPalette::ELimitAction_e" , 101 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveChunkManager = { "TEveChunkManager" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETArrayCmUcOallocatorlETArrayCmUgRsPgR = { "vector<TArrayC*,allocator<TArrayC*> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlETArrayCmUcOallocatorlETArrayCmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TArrayC*,allocator<TArrayC*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_allocatorlEintgR = { "allocator<int>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR = { "set<int,less<int>,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveSecondarySelectable = { "TEveSecondarySelectable" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TRefArray = { "TRefArray" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveDigitSet = { "TEveDigitSet" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveDigitSetEditor = { "TEveDigitSetEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveDigitSetGL = { "TEveDigitSetGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveDigitSetcLcLERenderMode_e = { "TEveDigitSet::ERenderMode_e" , 101 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveDigitSetcLcLDigitBase_t = { "TEveDigitSet::DigitBase_t" , 115 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveBoxSet = { "TEveBoxSet" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveBoxSetGL = { "TEveBoxSetGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveBoxSetcLcLEBoxType_e = { "TEveBoxSet::EBoxType_e" , 101 , -1 };
G__linked_taginfo G__G__Eve2LN_TH2F = { "TH2F" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_THStack = { "THStack" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCaloData = { "TEveCaloData" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCaloDatacLcLSliceInfo_t = { "TEveCaloData::SliceInfo_t" , 115 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgR = { "vector<TEveCaloData::SliceInfo_t,allocator<TEveCaloData::SliceInfo_t> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgRcLcLiterator = { "vector<TEveCaloData::SliceInfo_t,allocator<TEveCaloData::SliceInfo_t> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TEveCaloData::SliceInfo_t,allocator<TEveCaloData::SliceInfo_t> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCaloDatacLcLCellId_t = { "TEveCaloData::CellId_t" , 115 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCaloDatacLcLCellGeom_t = { "TEveCaloData::CellGeom_t" , 115 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCaloDatacLcLCellData_t = { "TEveCaloData::CellData_t" , 115 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCaloDatacLcLRebinData_t = { "TEveCaloData::RebinData_t" , 115 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlEfloatcOallocatorlEfloatgRsPgR = { "vector<float,allocator<float> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlEfloatcOallocatorlEfloatgRsPgRcLcLiterator = { "vector<float,allocator<float> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<float,allocator<float> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgR = { "vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRcLcLiterator = { "vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgR = { "vector<TEveCaloData::CellGeom_t,allocator<TEveCaloData::CellGeom_t> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgRcLcLiterator = { "vector<TEveCaloData::CellGeom_t,allocator<TEveCaloData::CellGeom_t> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TEveCaloData::CellGeom_t,allocator<TEveCaloData::CellGeom_t> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCaloDataVec = { "TEveCaloDataVec" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR = { "vector<vector<float,allocator<float> >,allocator<vector<float,allocator<float> > > >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiterator = { "vector<vector<float,allocator<float> >,allocator<vector<float,allocator<float> > > >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<float,allocator<float> >,allocator<vector<float,allocator<float> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCaloDataHist = { "TEveCaloDataHist" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveProjectioncLcLEPType_e = { "TEveProjection::EPType_e" , 101 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR = { "vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TEveProjection::PreScaleEntry_t,allocator<TEveProjection::PreScaleEntry_t> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCaloViz = { "TEveCaloViz" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCaloVizEditor = { "TEveCaloVizEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCalo3D = { "TEveCalo3D" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCalo3DGL = { "TEveCalo3DGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCalo2D = { "TEveCalo2D" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCalo2DGL = { "TEveCalo2DGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgR = { "vector<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >*,allocator<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >*> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgRcLcLiterator = { "vector<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >*,allocator<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >*> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >*,allocator<vector<TEveCaloData::CellId_t,allocator<TEveCaloData::CellId_t> >*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCaloLego = { "TEveCaloLego" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCaloLegoGL = { "TEveCaloLegoGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCaloLegoOverlay = { "TEveCaloLegoOverlay" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCaloLegocLcLEProjection_e = { "TEveCaloLego::EProjection_e" , 101 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCaloLegocLcLE2DMode_e = { "TEveCaloLego::E2DMode_e" , 101 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCaloLegocLcLEBoxMode_e = { "TEveCaloLego::EBoxMode_e" , 101 , -1 };
G__linked_taginfo G__G__Eve2LN_TGButton = { "TGButton" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGCheckButton = { "TGCheckButton" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGNumberEntry = { "TGNumberEntry" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGColorSelect = { "TGColorSelect" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGComboBox = { "TGComboBox" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCaloLegoEditor = { "TEveCaloLegoEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGLFont = { "TGLFont" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR = { "map<TGLFont,int,less<TGLFont>,allocator<pair<const TGLFont,int> > >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgR = { "list<const TGLFont*,allocator<const TGLFont*> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGLAxisPainter = { "TGLAxisPainter" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_pairlEfloatcOfloatgR = { "pair<float,float>" , 115 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR = { "vector<pair<float,float>,allocator<pair<float,float> > >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<float,float>,allocator<pair<float,float> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_pairlEfloatcOintgR = { "pair<float,int>" , 115 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR = { "vector<pair<float,int>,allocator<pair<float,int> > >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<float,int>,allocator<pair<float,int> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgR = { "vector<TEveCaloLegoGL::Cell2D_t,allocator<TEveCaloLegoGL::Cell2D_t> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgRcLcLiterator = { "vector<TEveCaloLegoGL::Cell2D_t,allocator<TEveCaloLegoGL::Cell2D_t> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TEveCaloLegoGL::Cell2D_t,allocator<TEveCaloLegoGL::Cell2D_t> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_maplEintcOunsignedsPintcOlesslEintgRcOallocatorlEpairlEconstsPintcOunsignedsPintgRsPgRsPgR = { "map<int,unsigned int,less<int>,allocator<pair<const int,unsigned int> > >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_maplEintcOunsignedsPintcOlesslEintgRcOallocatorlEpairlEconstsPintcOunsignedsPintgRsPgRsPgRcLcLiterator = { "map<int,unsigned int,less<int>,allocator<pair<const int,unsigned int> > >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGLOvlSelectRecord = { "TGLOvlSelectRecord" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGLOverlayElement = { "TGLOverlayElement" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_listlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgR = { "list<TGLOverlayElement*,allocator<TGLOverlayElement*> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGLCameraOverlay = { "TGLCameraOverlay" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveGDoubleValuator = { "TEveGDoubleValuator" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGRadioButton = { "TGRadioButton" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveCalo3DEditor = { "TEveCalo3DEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveGeoNode = { "TEveGeoNode" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveGeoTopNode = { "TEveGeoTopNode" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveGeoNodeEditor = { "TEveGeoNodeEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveGeoTopNodeEditor = { "TEveGeoTopNodeEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGeoVolume = { "TGeoVolume" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGeoNode = { "TGeoNode" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGeoShape = { "TGeoShape" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGeoCompositeShape = { "TGeoCompositeShape" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveGeoShapeExtract = { "TEveGeoShapeExtract" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveGeoShape = { "TEveGeoShape" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveGeoShapeProjected = { "TEveGeoShapeProjected" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_listlETGeoShapemUcOallocatorlETGeoShapemUgRsPgR = { "list<TGeoShape*,allocator<TGeoShape*> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGeoBBox = { "TGeoBBox" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGLFaceSet = { "TGLFaceSet" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveGeoPolyShape = { "TEveGeoPolyShape" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveGridStepper = { "TEveGridStepper" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveGridStepperSubEditor = { "TEveGridStepperSubEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveGridStepperEditor = { "TEveGridStepperEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveGridSteppercLcLEStepMode_e = { "TEveGridStepper::EStepMode_e" , 101 , -1 };
G__linked_taginfo G__G__Eve2LN_TGEventHandler = { "TGEventHandler" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGLEventHandler = { "TGLEventHandler" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveLegoEventHandler = { "TEveLegoEventHandler" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveLegoEventHandlercLcLEMode_e = { "TEveLegoEventHandler::EMode_e" , 101 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveLine = { "TEveLine" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveLineEditor = { "TEveLineEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TPointSet3DGL = { "TPointSet3DGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveLineGL = { "TEveLineGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEvePointSelector = { "TEvePointSelector" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEvePointSelectorConsumer = { "TEvePointSelectorConsumer" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEvePointSelectorConsumercLcLETreeVarType_e = { "TEvePointSelectorConsumer::ETreeVarType_e" , 101 , -1 };
G__linked_taginfo G__G__Eve2LN_TPolyMarker3D = { "TPolyMarker3D" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TPointSet3D = { "TPointSet3D" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEvePointSet = { "TEvePointSet" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEvePointSetArray = { "TEvePointSetArray" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEvePointSetArrayEditor = { "TEvePointSetArrayEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEvePointSetProjected = { "TEvePointSetProjected" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveLineProjected = { "TEveLineProjected" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEvePolygonSetProjected = { "TEvePolygonSetProjected" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEvePolygonSetProjectedGL = { "TEvePolygonSetProjectedGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEvePolygonSetProjectedcLcLPolygon_t = { "TEvePolygonSetProjected::Polygon_t" , 115 , -1 };
G__linked_taginfo G__G__Eve2LN_allocatorlETEvePolygonSetProjectedcLcLPolygon_tgR = { "allocator<TEvePolygonSetProjected::Polygon_t>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_listlETEvePolygonSetProjectedcLcLPolygon_tcOallocatorlETEvePolygonSetProjectedcLcLPolygon_tgRsPgR = { "list<TEvePolygonSetProjected::Polygon_t,allocator<TEvePolygonSetProjected::Polygon_t> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_listlETEvePolygonSetProjectedcLcLPolygon_tcOallocatorlETEvePolygonSetProjectedcLcLPolygon_tgRsPgRcLcLiterator = { "list<TEvePolygonSetProjected::Polygon_t,allocator<TEvePolygonSetProjected::Polygon_t> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_listlEintcOallocatorlEintgRsPgR = { "list<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveQuadSet = { "TEveQuadSet" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveQuadSetGL = { "TEveQuadSetGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e = { "TEveQuadSet::EQuadType_e" , 101 , -1 };
G__linked_taginfo G__G__Eve2LN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TElementActionTlEfloatgR = { "TElementActionT<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TElementPosActionTlEfloatgR = { "TElementPosActionT<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMatrixTlEfloatgR = { "TMatrixT<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMatrixTRow_constlEfloatgR = { "TMatrixTRow_const<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMatrixTRowlEfloatgR = { "TMatrixTRow<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMatrixTDiag_constlEfloatgR = { "TMatrixTDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMatrixTColumn_constlEfloatgR = { "TMatrixTColumn_const<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMatrixTFlat_constlEfloatgR = { "TMatrixTFlat_const<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMatrixTSub_constlEfloatgR = { "TMatrixTSub_const<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMatrixTSparseRow_constlEfloatgR = { "TMatrixTSparseRow_const<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMatrixTSparseDiag_constlEfloatgR = { "TMatrixTSparseDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMatrixTColumnlEfloatgR = { "TMatrixTColumn<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMatrixTDiaglEfloatgR = { "TMatrixTDiag<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMatrixTFlatlEfloatgR = { "TMatrixTFlat<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMatrixTSublEfloatgR = { "TMatrixTSub<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMatrixTSparseRowlEfloatgR = { "TMatrixTSparseRow<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMatrixTSparseDiaglEfloatgR = { "TMatrixTSparseDiag<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveStraightLineSet = { "TEveStraightLineSet" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveStraightLineSetcLcLLine_t = { "TEveStraightLineSet::Line_t" , 115 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveStraightLineSetProjected = { "TEveStraightLineSetProjected" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveScalableStraightLineSet = { "TEveScalableStraightLineSet" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveStraightLineSetEditor = { "TEveStraightLineSetEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveStraightLineSetGL = { "TEveStraightLineSetGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGTextEntry = { "TGTextEntry" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveText = { "TEveText" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTextEditor = { "TEveTextEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTextGL = { "TEveTextGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTrackPropagatorSubEditor = { "TEveTrackPropagatorSubEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTrack = { "TEveTrack" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTrackList = { "TEveTrackList" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTrackEditor = { "TEveTrackEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTrackListEditor = { "TEveTrackListEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTrackGL = { "TEveTrackGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEvePathMarkTlEfloatgR = { "TEvePathMarkT<float>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEvePathMarkTlEdoublegR = { "TEvePathMarkT<double>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TMarker = { "TMarker" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTrackPropagator = { "TEveTrackPropagator" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveRecTrack = { "TEveRecTrack" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveMCTrack = { "TEveMCTrack" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TParticle = { "TParticle" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgR = { "vector<TEvePathMarkT<float>,allocator<TEvePathMarkT<float> > >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgRcLcLiterator = { "vector<TEvePathMarkT<float>,allocator<TEvePathMarkT<float> > >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TEvePathMarkT<float>,allocator<TEvePathMarkT<float> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTrackcLcLEBreakProjectedTracks_e = { "TEveTrack::EBreakProjectedTracks_e" , 101 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTrackProjected = { "TEveTrackProjected" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTrackProjectedGL = { "TEveTrackProjectedGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTrackListProjected = { "TEveTrackListProjected" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TAttMarkerEditor = { "TAttMarkerEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTrackPropagatorEditor = { "TEveTrackPropagatorEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveMagField = { "TEveMagField" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveMagFieldConst = { "TEveMagFieldConst" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveMagFieldDuo = { "TEveMagFieldDuo" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTrackPropagatorcLcLHelix_t = { "TEveTrackPropagator::Helix_t" , 115 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTrackPropagatorcLcLEStepper_e = { "TEveTrackPropagator::EStepper_e" , 101 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTrackPropagatorcLcLEProjTrackBreaking_e = { "TEveTrackPropagator::EProjTrackBreaking_e" , 101 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETEveVector4TlEfloatgRcOallocatorlETEveVector4TlEfloatgRsPgRsPgR = { "vector<TEveVector4T<float>,allocator<TEveVector4T<float> > >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlETEveVector4TlEfloatgRcOallocatorlETEveVector4TlEfloatgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TEveVector4T<float>,allocator<TEveVector4T<float> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTriangleSet = { "TEveTriangleSet" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTriangleSetEditor = { "TEveTriangleSetEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveTriangleSetGL = { "TEveTriangleSetGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveJetCone = { "TEveJetCone" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveJetConeEditor = { "TEveJetConeEditor" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveJetConeProjected = { "TEveJetConeProjected" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveJetConeGL = { "TEveJetConeGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_vectorlETEveVectorTlEfloatgRcOallocatorlETEveVectorTlEfloatgRsPgRsPgR = { "vector<TEveVectorT<float>,allocator<TEveVectorT<float> > >" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_reverse_iteratorlEvectorlETEveVectorTlEfloatgRcOallocatorlETEveVectorTlEfloatgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TEveVectorT<float>,allocator<TEveVectorT<float> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEveJetConeProjectedGL = { "TEveJetConeProjectedGL" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEvePlot3D = { "TEvePlot3D" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TGLPlot3D = { "TGLPlot3D" , 99 , -1 };
G__linked_taginfo G__G__Eve2LN_TEvePlot3DGL = { "TEvePlot3DGL" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Eve2() {
  G__G__Eve2LN_TClass.tagnum = -1 ;
  G__G__Eve2LN_TBuffer.tagnum = -1 ;
  G__G__Eve2LN_TMemberInspector.tagnum = -1 ;
  G__G__Eve2LN_TObject.tagnum = -1 ;
  G__G__Eve2LN_TNamed.tagnum = -1 ;
  G__G__Eve2LN_TString.tagnum = -1 ;
  G__G__Eve2LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__Eve2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_TList.tagnum = -1 ;
  G__G__Eve2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_Event_t.tagnum = -1 ;
  G__G__Eve2LN_TGObject.tagnum = -1 ;
  G__G__Eve2LN_TQObject.tagnum = -1 ;
  G__G__Eve2LN_TGWindow.tagnum = -1 ;
  G__G__Eve2LN_TGPicture.tagnum = -1 ;
  G__G__Eve2LN_TAttLine.tagnum = -1 ;
  G__G__Eve2LN_TAttMarker.tagnum = -1 ;
  G__G__Eve2LN_TGFrame.tagnum = -1 ;
  G__G__Eve2LN_TGCompositeFrame.tagnum = -1 ;
  G__G__Eve2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__Eve2LN_TGTextButton.tagnum = -1 ;
  G__G__Eve2LN_TGVerticalFrame.tagnum = -1 ;
  G__G__Eve2LN_TGHorizontalFrame.tagnum = -1 ;
  G__G__Eve2LN_TGLabel.tagnum = -1 ;
  G__G__Eve2LN_TGedFrame.tagnum = -1 ;
  G__G__Eve2LN_TEveGValuator.tagnum = -1 ;
  G__G__Eve2LN_TEveArrow.tagnum = -1 ;
  G__G__Eve2LN_TEveGTriVecValuator.tagnum = -1 ;
  G__G__Eve2LN_TEveArrowEditor.tagnum = -1 ;
  G__G__Eve2LN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlETGLPlanecOallocatorlETGLPlanegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_pairlEboolcOTGLLine3gR.tagnum = -1 ;
  G__G__Eve2LN_pairlEboolcOTGLVertex3gR.tagnum = -1 ;
  G__G__Eve2LN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_TAxis.tagnum = -1 ;
  G__G__Eve2LN_pairlEintcOintgR.tagnum = -1 ;
  G__G__Eve2LN_pairlEdoublecOdoublegR.tagnum = -1 ;
  G__G__Eve2LN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_TBuffer3D.tagnum = -1 ;
  G__G__Eve2LN_TGLPhysicalShape.tagnum = -1 ;
  G__G__Eve2LN_TGLRnrCtx.tagnum = -1 ;
  G__G__Eve2LN_TGLSelectRecord.tagnum = -1 ;
  G__G__Eve2LN_TGLLogicalShape.tagnum = -1 ;
  G__G__Eve2LN_TGLObject.tagnum = -1 ;
  G__G__Eve2LN_TEveArrowGL.tagnum = -1 ;
  G__G__Eve2LN_TGeoManager.tagnum = -1 ;
  G__G__Eve2LN_TEveElement.tagnum = -1 ;
  G__G__Eve2LN_TEveException.tagnum = -1 ;
  G__G__Eve2LN_TEveRefCnt.tagnum = -1 ;
  G__G__Eve2LN_TEveRefBackPtr.tagnum = -1 ;
  G__G__Eve2LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_TEveProjection.tagnum = -1 ;
  G__G__Eve2LN_TEveProjected.tagnum = -1 ;
  G__G__Eve2LN_TEveProjectionManager.tagnum = -1 ;
  G__G__Eve2LN_TEveProjectable.tagnum = -1 ;
  G__G__Eve2LN_listlETEveProjectedmUcOallocatorlETEveProjectedmUgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_TGListTree.tagnum = -1 ;
  G__G__Eve2LN_TGListTreeItem.tagnum = -1 ;
  G__G__Eve2LN_TEveTrans.tagnum = -1 ;
  G__G__Eve2LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgR.tagnum = -1 ;
  G__G__Eve2LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_TEveElementList.tagnum = -1 ;
  G__G__Eve2LN_TEveVectorTlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TEveVectorTlEdoublegR.tagnum = -1 ;
  G__G__Eve2LN_TEveVector4TlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TEveVector4TlEdoublegR.tagnum = -1 ;
  G__G__Eve2LN_TEveVector2TlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TEveVector2TlEdoublegR.tagnum = -1 ;
  G__G__Eve2LN_TAtt3D.tagnum = -1 ;
  G__G__Eve2LN_TAttBBox.tagnum = -1 ;
  G__G__Eve2LN_TEveBox.tagnum = -1 ;
  G__G__Eve2LN_TEveBoxProjected.tagnum = -1 ;
  G__G__Eve2LN_TEveBoxGL.tagnum = -1 ;
  G__G__Eve2LN_TEveBoxProjectedGL.tagnum = -1 ;
  G__G__Eve2LN_TArrayI.tagnum = -1 ;
  G__G__Eve2LN_TEveShape.tagnum = -1 ;
  G__G__Eve2LN_TEveShapeEditor.tagnum = -1 ;
  G__G__Eve2LN_vectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_vectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_TEveFrameBox.tagnum = -1 ;
  G__G__Eve2LN_TEveFrameBoxGL.tagnum = -1 ;
  G__G__Eve2LN_TEveFrameBoxcLcLEFrameType_e.tagnum = -1 ;
  G__G__Eve2LN_TEveRGBAPalette.tagnum = -1 ;
  G__G__Eve2LN_TEveRGBAPaletteEditor.tagnum = -1 ;
  G__G__Eve2LN_TEveRGBAPaletteSubEditor.tagnum = -1 ;
  G__G__Eve2LN_TEveRGBAPalettecLcLELimitAction_e.tagnum = -1 ;
  G__G__Eve2LN_TEveChunkManager.tagnum = -1 ;
  G__G__Eve2LN_vectorlETArrayCmUcOallocatorlETArrayCmUgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlETArrayCmUcOallocatorlETArrayCmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_allocatorlEintgR.tagnum = -1 ;
  G__G__Eve2LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_TEveSecondarySelectable.tagnum = -1 ;
  G__G__Eve2LN_TRefArray.tagnum = -1 ;
  G__G__Eve2LN_TEveDigitSet.tagnum = -1 ;
  G__G__Eve2LN_TEveDigitSetEditor.tagnum = -1 ;
  G__G__Eve2LN_TEveDigitSetGL.tagnum = -1 ;
  G__G__Eve2LN_TEveDigitSetcLcLERenderMode_e.tagnum = -1 ;
  G__G__Eve2LN_TEveDigitSetcLcLDigitBase_t.tagnum = -1 ;
  G__G__Eve2LN_TEveBoxSet.tagnum = -1 ;
  G__G__Eve2LN_TEveBoxSetGL.tagnum = -1 ;
  G__G__Eve2LN_TEveBoxSetcLcLEBoxType_e.tagnum = -1 ;
  G__G__Eve2LN_TH2F.tagnum = -1 ;
  G__G__Eve2LN_THStack.tagnum = -1 ;
  G__G__Eve2LN_TEveCaloData.tagnum = -1 ;
  G__G__Eve2LN_TEveCaloDatacLcLSliceInfo_t.tagnum = -1 ;
  G__G__Eve2LN_vectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_vectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_TEveCaloDatacLcLCellId_t.tagnum = -1 ;
  G__G__Eve2LN_TEveCaloDatacLcLCellGeom_t.tagnum = -1 ;
  G__G__Eve2LN_TEveCaloDatacLcLCellData_t.tagnum = -1 ;
  G__G__Eve2LN_TEveCaloDatacLcLRebinData_t.tagnum = -1 ;
  G__G__Eve2LN_vectorlEfloatcOallocatorlEfloatgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_vectorlEfloatcOallocatorlEfloatgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_vectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_vectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_TEveCaloDataVec.tagnum = -1 ;
  G__G__Eve2LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_TEveCaloDataHist.tagnum = -1 ;
  G__G__Eve2LN_TEveProjectioncLcLEPType_e.tagnum = -1 ;
  G__G__Eve2LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_TEveCaloViz.tagnum = -1 ;
  G__G__Eve2LN_TEveCaloVizEditor.tagnum = -1 ;
  G__G__Eve2LN_TEveCalo3D.tagnum = -1 ;
  G__G__Eve2LN_TEveCalo3DGL.tagnum = -1 ;
  G__G__Eve2LN_TEveCalo2D.tagnum = -1 ;
  G__G__Eve2LN_TEveCalo2DGL.tagnum = -1 ;
  G__G__Eve2LN_vectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_vectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_TEveCaloLego.tagnum = -1 ;
  G__G__Eve2LN_TEveCaloLegoGL.tagnum = -1 ;
  G__G__Eve2LN_TEveCaloLegoOverlay.tagnum = -1 ;
  G__G__Eve2LN_TEveCaloLegocLcLEProjection_e.tagnum = -1 ;
  G__G__Eve2LN_TEveCaloLegocLcLE2DMode_e.tagnum = -1 ;
  G__G__Eve2LN_TEveCaloLegocLcLEBoxMode_e.tagnum = -1 ;
  G__G__Eve2LN_TGButton.tagnum = -1 ;
  G__G__Eve2LN_TGCheckButton.tagnum = -1 ;
  G__G__Eve2LN_TGNumberEntry.tagnum = -1 ;
  G__G__Eve2LN_TGColorSelect.tagnum = -1 ;
  G__G__Eve2LN_TGComboBox.tagnum = -1 ;
  G__G__Eve2LN_TEveCaloLegoEditor.tagnum = -1 ;
  G__G__Eve2LN_TGLFont.tagnum = -1 ;
  G__G__Eve2LN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_TGLAxisPainter.tagnum = -1 ;
  G__G__Eve2LN_pairlEfloatcOfloatgR.tagnum = -1 ;
  G__G__Eve2LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_pairlEfloatcOintgR.tagnum = -1 ;
  G__G__Eve2LN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_vectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_vectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_maplEintcOunsignedsPintcOlesslEintgRcOallocatorlEpairlEconstsPintcOunsignedsPintgRsPgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_maplEintcOunsignedsPintcOlesslEintgRcOallocatorlEpairlEconstsPintcOunsignedsPintgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve2LN_TGLOvlSelectRecord.tagnum = -1 ;
  G__G__Eve2LN_TGLOverlayElement.tagnum = -1 ;
  G__G__Eve2LN_listlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_TGLCameraOverlay.tagnum = -1 ;
  G__G__Eve2LN_TEveGDoubleValuator.tagnum = -1 ;
  G__G__Eve2LN_TGRadioButton.tagnum = -1 ;
  G__G__Eve2LN_TEveCalo3DEditor.tagnum = -1 ;
  G__G__Eve2LN_TEveGeoNode.tagnum = -1 ;
  G__G__Eve2LN_TEveGeoTopNode.tagnum = -1 ;
  G__G__Eve2LN_TEveGeoNodeEditor.tagnum = -1 ;
  G__G__Eve2LN_TEveGeoTopNodeEditor.tagnum = -1 ;
  G__G__Eve2LN_TGeoVolume.tagnum = -1 ;
  G__G__Eve2LN_TGeoNode.tagnum = -1 ;
  G__G__Eve2LN_TGeoShape.tagnum = -1 ;
  G__G__Eve2LN_TGeoCompositeShape.tagnum = -1 ;
  G__G__Eve2LN_TEveGeoShapeExtract.tagnum = -1 ;
  G__G__Eve2LN_TEveGeoShape.tagnum = -1 ;
  G__G__Eve2LN_TEveGeoShapeProjected.tagnum = -1 ;
  G__G__Eve2LN_listlETGeoShapemUcOallocatorlETGeoShapemUgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_TGeoBBox.tagnum = -1 ;
  G__G__Eve2LN_TGLFaceSet.tagnum = -1 ;
  G__G__Eve2LN_TEveGeoPolyShape.tagnum = -1 ;
  G__G__Eve2LN_TEveGridStepper.tagnum = -1 ;
  G__G__Eve2LN_TEveGridStepperSubEditor.tagnum = -1 ;
  G__G__Eve2LN_TEveGridStepperEditor.tagnum = -1 ;
  G__G__Eve2LN_TEveGridSteppercLcLEStepMode_e.tagnum = -1 ;
  G__G__Eve2LN_TGEventHandler.tagnum = -1 ;
  G__G__Eve2LN_TGLEventHandler.tagnum = -1 ;
  G__G__Eve2LN_TEveLegoEventHandler.tagnum = -1 ;
  G__G__Eve2LN_TEveLegoEventHandlercLcLEMode_e.tagnum = -1 ;
  G__G__Eve2LN_TEveLine.tagnum = -1 ;
  G__G__Eve2LN_TEveLineEditor.tagnum = -1 ;
  G__G__Eve2LN_TPointSet3DGL.tagnum = -1 ;
  G__G__Eve2LN_TEveLineGL.tagnum = -1 ;
  G__G__Eve2LN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_TEvePointSelector.tagnum = -1 ;
  G__G__Eve2LN_TEvePointSelectorConsumer.tagnum = -1 ;
  G__G__Eve2LN_TEvePointSelectorConsumercLcLETreeVarType_e.tagnum = -1 ;
  G__G__Eve2LN_TPolyMarker3D.tagnum = -1 ;
  G__G__Eve2LN_TPointSet3D.tagnum = -1 ;
  G__G__Eve2LN_TEvePointSet.tagnum = -1 ;
  G__G__Eve2LN_TEvePointSetArray.tagnum = -1 ;
  G__G__Eve2LN_TEvePointSetArrayEditor.tagnum = -1 ;
  G__G__Eve2LN_TEvePointSetProjected.tagnum = -1 ;
  G__G__Eve2LN_TEveLineProjected.tagnum = -1 ;
  G__G__Eve2LN_TEvePolygonSetProjected.tagnum = -1 ;
  G__G__Eve2LN_TEvePolygonSetProjectedGL.tagnum = -1 ;
  G__G__Eve2LN_TEvePolygonSetProjectedcLcLPolygon_t.tagnum = -1 ;
  G__G__Eve2LN_allocatorlETEvePolygonSetProjectedcLcLPolygon_tgR.tagnum = -1 ;
  G__G__Eve2LN_listlETEvePolygonSetProjectedcLcLPolygon_tcOallocatorlETEvePolygonSetProjectedcLcLPolygon_tgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_listlETEvePolygonSetProjectedcLcLPolygon_tcOallocatorlETEvePolygonSetProjectedcLcLPolygon_tgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve2LN_listlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_TEveQuadSet.tagnum = -1 ;
  G__G__Eve2LN_TEveQuadSetGL.tagnum = -1 ;
  G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e.tagnum = -1 ;
  G__G__Eve2LN_TMatrixTBaselEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TMatrixTBaselEdoublegR.tagnum = -1 ;
  G__G__Eve2LN_TVectorTlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TVectorTlEdoublegR.tagnum = -1 ;
  G__G__Eve2LN_TElementActionTlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TElementPosActionTlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TMatrixTlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TMatrixTRow_constlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TMatrixTRowlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TMatrixTDiag_constlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TMatrixTColumn_constlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TMatrixTFlat_constlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TMatrixTSub_constlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TMatrixTSparseRow_constlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TMatrixTSparseDiag_constlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TMatrixTColumnlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TMatrixTDiaglEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TMatrixTFlatlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TMatrixTSublEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TMatrixTSparseRowlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TMatrixTSparseDiaglEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TEveStraightLineSet.tagnum = -1 ;
  G__G__Eve2LN_TEveStraightLineSetcLcLLine_t.tagnum = -1 ;
  G__G__Eve2LN_TEveStraightLineSetProjected.tagnum = -1 ;
  G__G__Eve2LN_TEveScalableStraightLineSet.tagnum = -1 ;
  G__G__Eve2LN_TEveStraightLineSetEditor.tagnum = -1 ;
  G__G__Eve2LN_TEveStraightLineSetGL.tagnum = -1 ;
  G__G__Eve2LN_TGTextEntry.tagnum = -1 ;
  G__G__Eve2LN_TEveText.tagnum = -1 ;
  G__G__Eve2LN_TEveTextEditor.tagnum = -1 ;
  G__G__Eve2LN_TEveTextGL.tagnum = -1 ;
  G__G__Eve2LN_TEveTrackPropagatorSubEditor.tagnum = -1 ;
  G__G__Eve2LN_TEveTrack.tagnum = -1 ;
  G__G__Eve2LN_TEveTrackList.tagnum = -1 ;
  G__G__Eve2LN_TEveTrackEditor.tagnum = -1 ;
  G__G__Eve2LN_TEveTrackListEditor.tagnum = -1 ;
  G__G__Eve2LN_TEveTrackGL.tagnum = -1 ;
  G__G__Eve2LN_TEvePathMarkTlEfloatgR.tagnum = -1 ;
  G__G__Eve2LN_TEvePathMarkTlEdoublegR.tagnum = -1 ;
  G__G__Eve2LN_TMarker.tagnum = -1 ;
  G__G__Eve2LN_TEveTrackPropagator.tagnum = -1 ;
  G__G__Eve2LN_TEveRecTrack.tagnum = -1 ;
  G__G__Eve2LN_TEveMCTrack.tagnum = -1 ;
  G__G__Eve2LN_TParticle.tagnum = -1 ;
  G__G__Eve2LN_vectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_vectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_TEveTrackcLcLEBreakProjectedTracks_e.tagnum = -1 ;
  G__G__Eve2LN_TEveTrackProjected.tagnum = -1 ;
  G__G__Eve2LN_TEveTrackProjectedGL.tagnum = -1 ;
  G__G__Eve2LN_TEveTrackListProjected.tagnum = -1 ;
  G__G__Eve2LN_TAttMarkerEditor.tagnum = -1 ;
  G__G__Eve2LN_TEveTrackPropagatorEditor.tagnum = -1 ;
  G__G__Eve2LN_TEveMagField.tagnum = -1 ;
  G__G__Eve2LN_TEveMagFieldConst.tagnum = -1 ;
  G__G__Eve2LN_TEveMagFieldDuo.tagnum = -1 ;
  G__G__Eve2LN_TEveTrackPropagatorcLcLHelix_t.tagnum = -1 ;
  G__G__Eve2LN_TEveTrackPropagatorcLcLEStepper_e.tagnum = -1 ;
  G__G__Eve2LN_TEveTrackPropagatorcLcLEProjTrackBreaking_e.tagnum = -1 ;
  G__G__Eve2LN_vectorlETEveVector4TlEfloatgRcOallocatorlETEveVector4TlEfloatgRsPgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlETEveVector4TlEfloatgRcOallocatorlETEveVector4TlEfloatgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_TEveTriangleSet.tagnum = -1 ;
  G__G__Eve2LN_TEveTriangleSetEditor.tagnum = -1 ;
  G__G__Eve2LN_TEveTriangleSetGL.tagnum = -1 ;
  G__G__Eve2LN_TEveJetCone.tagnum = -1 ;
  G__G__Eve2LN_TEveJetConeEditor.tagnum = -1 ;
  G__G__Eve2LN_TEveJetConeProjected.tagnum = -1 ;
  G__G__Eve2LN_TEveJetConeGL.tagnum = -1 ;
  G__G__Eve2LN_vectorlETEveVectorTlEfloatgRcOallocatorlETEveVectorTlEfloatgRsPgRsPgR.tagnum = -1 ;
  G__G__Eve2LN_reverse_iteratorlEvectorlETEveVectorTlEfloatgRcOallocatorlETEveVectorTlEfloatgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Eve2LN_TEveJetConeProjectedGL.tagnum = -1 ;
  G__G__Eve2LN_TEvePlot3D.tagnum = -1 ;
  G__G__Eve2LN_TGLPlot3D.tagnum = -1 ;
  G__G__Eve2LN_TEvePlot3DGL.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Eve2() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TClass);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TObject);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TString);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TList);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_Event_t);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGObject);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TQObject);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGWindow);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGPicture);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TAttLine);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TAttMarker);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGFrame);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGCompositeFrame);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGTextButton);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGVerticalFrame);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGHorizontalFrame);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGLabel);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGedFrame);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveGValuator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveArrow),sizeof(TEveArrow),-1,327424,"Class for gl visualisation of arrow.",G__setup_memvarTEveArrow,G__setup_memfuncTEveArrow);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveGTriVecValuator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveArrowEditor),sizeof(TEveArrowEditor),-1,327424,"GUI editor for TEveArrow.",G__setup_memvarTEveArrowEditor,G__setup_memfuncTEveArrowEditor);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETGLPlanecOallocatorlETGLPlanegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlETGLPlanecOallocatorlETGLPlanegRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_pairlEboolcOTGLLine3gR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_pairlEboolcOTGLVertex3gR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlEunsignedsPcharcOallocatorlEunsignedsPchargRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TAxis);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_pairlEintcOintgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_pairlEdoublecOdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlEdoublecOallocatorlEdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TBuffer3D);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGLPhysicalShape);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGLRnrCtx);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGLSelectRecord);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGLLogicalShape);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGLObject);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveArrowGL),sizeof(TEveArrowGL),-1,298752,"GL renderer class for TEveArrow.",G__setup_memvarTEveArrowGL,G__setup_memfuncTEveArrowGL);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGeoManager);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveElement);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveException);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveRefCnt);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveRefBackPtr);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_maplETEveElementmUcOintcOlesslETEveElementmUgRcOallocatorlEpairlETEveElementmUsPconstcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveProjection);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveProjected);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveProjectionManager);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveProjectable);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_listlETEveProjectedmUcOallocatorlETEveProjectedmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_setlETEveElementmUcOlesslETEveElementmUgRcOallocatorlETEveElementmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGListTree);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGListTreeItem);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTrans);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_setlETEveElementcLcLTEveListTreeInfocOlesslETEveElementcLcLTEveListTreeInfogRcOallocatorlETEveElementcLcLTEveListTreeInfogRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_listlETEveElementmUcOallocatorlETEveElementmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveElementList);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveVector4TlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveVector4TlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveVector2TlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveVector2TlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TAtt3D);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TAttBBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveBox),sizeof(TEveBox),-1,327424,"3D box with arbitrary vertices.",G__setup_memvarTEveBox,G__setup_memfuncTEveBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveBoxProjected),sizeof(TEveBoxProjected),-1,327424,"Projection of TEveBox.",G__setup_memvarTEveBoxProjected,G__setup_memfuncTEveBoxProjected);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveBoxGL),sizeof(TEveBoxGL),-1,298752,"GL renderer class for TEveBox.",G__setup_memvarTEveBoxGL,G__setup_memfuncTEveBoxGL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveBoxProjectedGL),sizeof(TEveBoxProjectedGL),-1,298752,"GL renderer class for TEveBoxProjected.",G__setup_memvarTEveBoxProjectedGL,G__setup_memfuncTEveBoxProjectedGL);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TArrayI);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveShape),sizeof(TEveShape),-1,327425,"Abstract base-class for 2D/3D shapes.",G__setup_memvarTEveShape,G__setup_memfuncTEveShape);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveShapeEditor),sizeof(TEveShapeEditor),-1,327424,"GUI editor for TEveShape.",G__setup_memvarTEveShapeEditor,G__setup_memfuncTEveShapeEditor);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveVector2TlEfloatgRcOallocatorlETEveVector2TlEfloatgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveFrameBox),sizeof(TEveFrameBox),-1,294656,"Description of a 2D or 3D frame that can be used to visually group a set of objects.",G__setup_memvarTEveFrameBox,G__setup_memfuncTEveFrameBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveFrameBoxGL),sizeof(TEveFrameBoxGL),-1,265984,"GL-renderer for TEveFrameBox class.",G__setup_memvarTEveFrameBoxGL,G__setup_memfuncTEveFrameBoxGL);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveFrameBoxcLcLEFrameType_e);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveRGBAPalette),sizeof(TEveRGBAPalette),-1,327424,"A generic, speed-optimised mapping from value to RGBA color supporting different wrapping and range truncation modes.",G__setup_memvarTEveRGBAPalette,G__setup_memfuncTEveRGBAPalette);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveRGBAPaletteEditor),sizeof(TEveRGBAPaletteEditor),-1,327424,"Editor for TEveRGBAPalette class.",G__setup_memvarTEveRGBAPaletteEditor,G__setup_memfuncTEveRGBAPaletteEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveRGBAPaletteSubEditor),sizeof(TEveRGBAPaletteSubEditor),-1,327168,"Sub-editor for TEveRGBAPalette class.",G__setup_memvarTEveRGBAPaletteSubEditor,G__setup_memfuncTEveRGBAPaletteSubEditor);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveRGBAPalettecLcLELimitAction_e);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveChunkManager);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETArrayCmUcOallocatorlETArrayCmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlETArrayCmUcOallocatorlETArrayCmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_allocatorlEintgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_setlEintcOlesslEintgRcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveSecondarySelectable);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TRefArray);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveDigitSet),sizeof(TEveDigitSet),-1,327425,"Base-class for storage of digit collections; provides transformation matrix (TEveTrans), signal to color mapping (TEveRGBAPalette) and visual grouping (TEveFrameBox).",G__setup_memvarTEveDigitSet,G__setup_memfuncTEveDigitSet);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveDigitSetEditor),sizeof(TEveDigitSetEditor),-1,327424,"Editor for TEveDigitSet class.",G__setup_memvarTEveDigitSetEditor,G__setup_memfuncTEveDigitSetEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveDigitSetGL),sizeof(TEveDigitSetGL),-1,298754,"GL renderer class for TEveDigitSet.",G__setup_memvarTEveDigitSetGL,G__setup_memfuncTEveDigitSetGL);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveDigitSetcLcLERenderMode_e);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveDigitSetcLcLDigitBase_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveBoxSet),sizeof(TEveBoxSet),-1,327424,"Collection of 3D primitives (fixed-size boxes, boxes of different sizes, or arbitrary sexto-epipeds); each primitive can be assigned a signal value and a TRef.",G__setup_memvarTEveBoxSet,G__setup_memfuncTEveBoxSet);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveBoxSetGL),sizeof(TEveBoxSetGL),-1,298752,"GL-renderer for TEveBoxSet class.",G__setup_memvarTEveBoxSetGL,G__setup_memfuncTEveBoxSetGL);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveBoxSetcLcLEBoxType_e);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TH2F);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_THStack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCaloData),sizeof(TEveCaloData),-1,327429,"Manages calorimeter event data.",G__setup_memvarTEveCaloData,G__setup_memfuncTEveCaloData);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCaloDatacLcLSliceInfo_t),sizeof(TEveCaloData::SliceInfo_t),-1,263424,"Slice info for histogram stack.",G__setup_memvarTEveCaloDatacLcLSliceInfo_t,G__setup_memfuncTEveCaloDatacLcLSliceInfo_t);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloDatacLcLSliceInfo_tcOallocatorlETEveCaloDatacLcLSliceInfo_tgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCaloDatacLcLCellId_t);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCaloDatacLcLCellGeom_t);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCaloDatacLcLCellData_t);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCaloDatacLcLRebinData_t);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlEfloatcOallocatorlEfloatgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlEfloatcOallocatorlEfloatgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlEintcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloDatacLcLCellGeom_tcOallocatorlETEveCaloDatacLcLCellGeom_tgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCaloDataVec),sizeof(TEveCaloDataVec),-1,65024,"Manages calorimeter event data.",G__setup_memvarTEveCaloDataVec,G__setup_memfuncTEveCaloDataVec);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCaloDataHist),sizeof(TEveCaloDataHist),-1,327424,"Manages calorimeter TH2F event data.",G__setup_memvarTEveCaloDataHist,G__setup_memfuncTEveCaloDataHist);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveProjectioncLcLEPType_e);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveProjectioncLcLPreScaleEntry_tcOallocatorlETEveProjectioncLcLPreScaleEntry_tgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCaloViz),sizeof(TEveCaloViz),-1,327426,"Base-class for visualization of calorimeter eventdata.",G__setup_memvarTEveCaloViz,G__setup_memfuncTEveCaloViz);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCaloVizEditor),sizeof(TEveCaloVizEditor),-1,327424,"GUI editor for TEveCaloVizEditor.",G__setup_memvarTEveCaloVizEditor,G__setup_memfuncTEveCaloVizEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCalo3D),sizeof(TEveCalo3D),-1,327424,"Class for 3D visualization of calorimeter event data.",G__setup_memvarTEveCalo3D,G__setup_memfuncTEveCalo3D);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCalo3DGL),sizeof(TEveCalo3DGL),-1,298752,"GL renderer class for TEveCalo.",G__setup_memvarTEveCalo3DGL,G__setup_memfuncTEveCalo3DGL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCalo2D),sizeof(TEveCalo2D),-1,327424,"Class for visualization of projected calorimeter event data.",G__setup_memvarTEveCalo2D,G__setup_memfuncTEveCalo2D);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCalo2DGL),sizeof(TEveCalo2DGL),-1,298752,"GL renderer class for TEveCalo2D.",G__setup_memvarTEveCalo2DGL,G__setup_memfuncTEveCalo2DGL);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUcOallocatorlEvectorlETEveCaloDatacLcLCellId_tcOallocatorlETEveCaloDatacLcLCellId_tgRsPgRmUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCaloLego),sizeof(TEveCaloLego),-1,327424,"Class for visualization of calorimeter histogram data.",G__setup_memvarTEveCaloLego,G__setup_memfuncTEveCaloLego);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCaloLegoGL),sizeof(TEveCaloLegoGL),-1,298752,"GL renderer class for TEveCaloLego.",G__setup_memvarTEveCaloLegoGL,G__setup_memfuncTEveCaloLegoGL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCaloLegoOverlay),sizeof(TEveCaloLegoOverlay),-1,265984,"GL-overaly control GUI for TEveCaloLego.",G__setup_memvarTEveCaloLegoOverlay,G__setup_memfuncTEveCaloLegoOverlay);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCaloLegocLcLEProjection_e);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCaloLegocLcLE2DMode_e);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCaloLegocLcLEBoxMode_e);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGButton);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGCheckButton);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGNumberEntry);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGColorSelect);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGComboBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCaloLegoEditor),sizeof(TEveCaloLegoEditor),-1,327424,"GUI editor for TEveCaloLego.",G__setup_memvarTEveCaloLegoEditor,G__setup_memfuncTEveCaloLegoEditor);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGLFont);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_maplETGLFontcOintcOlesslETGLFontgRcOallocatorlEpairlEconstsPTGLFontcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_listlEconstsPTGLFontmUcOallocatorlEconstsPTGLFontmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGLAxisPainter);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_pairlEfloatcOfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_pairlEfloatcOintgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlEpairlEfloatcOintgRcOallocatorlEpairlEfloatcOintgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveCaloLegoGLcLcLCell2D_tcOallocatorlETEveCaloLegoGLcLcLCell2D_tgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_maplEintcOunsignedsPintcOlesslEintgRcOallocatorlEpairlEconstsPintcOunsignedsPintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_maplEintcOunsignedsPintcOlesslEintgRcOallocatorlEpairlEconstsPintcOunsignedsPintgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGLOvlSelectRecord);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGLOverlayElement);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_listlETGLOverlayElementmUcOallocatorlETGLOverlayElementmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGLCameraOverlay);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveGDoubleValuator);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGRadioButton);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveCalo3DEditor),sizeof(TEveCalo3DEditor),-1,327424,"GUI editor for TEveCalo3DEditor.",G__setup_memvarTEveCalo3DEditor,G__setup_memfuncTEveCalo3DEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveGeoNode),sizeof(TEveGeoNode),-1,326144,"Wrapper for TGeoNode that allows it to be shown in GUI and controlled as a TEveElement.",G__setup_memvarTEveGeoNode,G__setup_memfuncTEveGeoNode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveGeoTopNode),sizeof(TEveGeoTopNode),-1,327168,"Top-level TEveGeoNode with a pointer to TGeoManager and controls for steering of TGeoPainter.",G__setup_memvarTEveGeoTopNode,G__setup_memfuncTEveGeoTopNode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveGeoNodeEditor),sizeof(TEveGeoNodeEditor),-1,327424,"Editor for TEveGeoNode class.",G__setup_memvarTEveGeoNodeEditor,G__setup_memfuncTEveGeoNodeEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveGeoTopNodeEditor),sizeof(TEveGeoTopNodeEditor),-1,327424,"Editor for TEveGeoTopNode class.",G__setup_memvarTEveGeoTopNodeEditor,G__setup_memfuncTEveGeoTopNodeEditor);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGeoVolume);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGeoNode);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGeoShape);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGeoCompositeShape);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveGeoShapeExtract),sizeof(TEveGeoShapeExtract),-1,327424,"Globally positioned TGeoShape with rendering attributes and an optional list of daughter shape-extracts.",G__setup_memvarTEveGeoShapeExtract,G__setup_memfuncTEveGeoShapeExtract);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveGeoShape),sizeof(TEveGeoShape),-1,327424,"Wrapper for TGeoShape with absolute positioning and color attributes allowing display of extracted TGeoShape's (without an active TGeoManager) and simplified geometries (needed for NLT projections).",G__setup_memvarTEveGeoShape,G__setup_memfuncTEveGeoShape);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveGeoShapeProjected),sizeof(TEveGeoShapeProjected),-1,327424,(char*)NULL,G__setup_memvarTEveGeoShapeProjected,G__setup_memfuncTEveGeoShapeProjected);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_listlETGeoShapemUcOallocatorlETGeoShapemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGeoBBox);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGLFaceSet);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveGeoPolyShape),sizeof(TEveGeoPolyShape),-1,327424,"A shape with arbitrary tesselation for visualization of CSG shapes.",G__setup_memvarTEveGeoPolyShape,G__setup_memfuncTEveGeoPolyShape);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveGridStepper),sizeof(TEveGridStepper),-1,294656,"Provide discrete position coordinates for placement of objects on regular grids.",G__setup_memvarTEveGridStepper,G__setup_memfuncTEveGridStepper);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveGridStepperSubEditor),sizeof(TEveGridStepperSubEditor),-1,327168,"Sub-editor for TEveGridStepper class.",G__setup_memvarTEveGridStepperSubEditor,G__setup_memfuncTEveGridStepperSubEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveGridStepperEditor),sizeof(TEveGridStepperEditor),-1,327424,"Editor for TEveGridStepper class.",G__setup_memvarTEveGridStepperEditor,G__setup_memfuncTEveGridStepperEditor);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveGridSteppercLcLEStepMode_e);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGEventHandler);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGLEventHandler);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveLegoEventHandler),sizeof(TEveLegoEventHandler),-1,327168,"A GL event handler class. Swiches perspective or orthographic camera.",G__setup_memvarTEveLegoEventHandler,G__setup_memfuncTEveLegoEventHandler);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveLegoEventHandlercLcLEMode_e);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveLine),sizeof(TEveLine),-1,327424,"An arbitrary polyline with fixed line and marker attributes.",G__setup_memvarTEveLine,G__setup_memfuncTEveLine);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveLineEditor),sizeof(TEveLineEditor),-1,327424,"Editor for TEveLine class.",G__setup_memvarTEveLineEditor,G__setup_memfuncTEveLineEditor);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TPointSet3DGL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveLineGL),sizeof(TEveLineGL),-1,298752,"GL-renderer for TEveLine class.",G__setup_memvarTEveLineGL,G__setup_memfuncTEveLineGL);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETStringcOallocatorlETStringgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEvePointSelector);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEvePointSelectorConsumer);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEvePointSelectorConsumercLcLETreeVarType_e);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TPolyMarker3D);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TPointSet3D);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEvePointSet),sizeof(TEvePointSet),-1,327424,"Set of 3D points with same marker attributes; optionally each point can be assigned an external TRef or a number of integer indices.",G__setup_memvarTEvePointSet,G__setup_memfuncTEvePointSet);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEvePointSetArray),sizeof(TEvePointSetArray),-1,327424,"Array of TEvePointSet's filled via a common point-source; range of displayed TEvePointSet's can be controlled, based on a separating quantity provided on fill-time by a user.",G__setup_memvarTEvePointSetArray,G__setup_memfuncTEvePointSetArray);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEvePointSetArrayEditor),sizeof(TEvePointSetArrayEditor),-1,327424,"Editor for TEvePointSetArray class.",G__setup_memvarTEvePointSetArrayEditor,G__setup_memfuncTEvePointSetArrayEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEvePointSetProjected),sizeof(TEvePointSetProjected),-1,327424,"Projected copy of a TEvePointSet.",G__setup_memvarTEvePointSetProjected,G__setup_memfuncTEvePointSetProjected);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveLineProjected),sizeof(TEveLineProjected),-1,327424,"Projected replica of a TEveLine.",G__setup_memvarTEveLineProjected,G__setup_memfuncTEveLineProjected);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEvePolygonSetProjected),sizeof(TEvePolygonSetProjected),-1,327424,"Set of projected polygons with outline; typically produced from a TBuffer3D.",G__setup_memvarTEvePolygonSetProjected,G__setup_memfuncTEvePolygonSetProjected);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEvePolygonSetProjectedGL),sizeof(TEvePolygonSetProjectedGL),-1,296192,"GL-renderer for TEvePolygonSetProjected class.",G__setup_memvarTEvePolygonSetProjectedGL,G__setup_memfuncTEvePolygonSetProjectedGL);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEvePolygonSetProjectedcLcLPolygon_t);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_allocatorlETEvePolygonSetProjectedcLcLPolygon_tgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_listlETEvePolygonSetProjectedcLcLPolygon_tcOallocatorlETEvePolygonSetProjectedcLcLPolygon_tgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_listlETEvePolygonSetProjectedcLcLPolygon_tcOallocatorlETEvePolygonSetProjectedcLcLPolygon_tgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_listlEintcOallocatorlEintgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveQuadSet),sizeof(TEveQuadSet),-1,327424,"Collection of 2D primitives (rectangles, hexagons, or lines); each primitive can be assigned a signal value and a TRef.",G__setup_memvarTEveQuadSet,G__setup_memfuncTEveQuadSet);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveQuadSetGL),sizeof(TEveQuadSetGL),-1,298752,"GL-renderer for TEveQuadSet class.",G__setup_memvarTEveQuadSetGL,G__setup_memfuncTEveQuadSetGL);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveQuadSetcLcLEQuadType_e);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMatrixTBaselEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMatrixTBaselEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TElementActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TElementPosActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMatrixTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMatrixTRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMatrixTRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMatrixTDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMatrixTColumn_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMatrixTFlat_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMatrixTSub_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMatrixTSparseRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMatrixTSparseDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMatrixTColumnlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMatrixTDiaglEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMatrixTFlatlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMatrixTSublEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMatrixTSparseRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMatrixTSparseDiaglEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveStraightLineSet),sizeof(TEveStraightLineSet),-1,327424,"Set of straight lines with optional markers along the lines.",G__setup_memvarTEveStraightLineSet,G__setup_memfuncTEveStraightLineSet);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveStraightLineSetcLcLLine_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveStraightLineSetProjected),sizeof(TEveStraightLineSetProjected),-1,327424,"Projected copy of a TEveStraightLineSet.",G__setup_memvarTEveStraightLineSetProjected,G__setup_memfuncTEveStraightLineSetProjected);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveScalableStraightLineSet),sizeof(TEveScalableStraightLineSet),-1,327424,"Straight-line-set with extra scaling.",G__setup_memvarTEveScalableStraightLineSet,G__setup_memfuncTEveScalableStraightLineSet);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveStraightLineSetEditor),sizeof(TEveStraightLineSetEditor),-1,327424,"Editor for TEveStraightLineSet class.",G__setup_memvarTEveStraightLineSetEditor,G__setup_memfuncTEveStraightLineSetEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveStraightLineSetGL),sizeof(TEveStraightLineSetGL),-1,298752,"GL-renderer for TEveStraightLineSet class.",G__setup_memvarTEveStraightLineSetGL,G__setup_memfuncTEveStraightLineSetGL);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGTextEntry);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveText),sizeof(TEveText),-1,327424,"Class for visualisation of text with FTGL font.",G__setup_memvarTEveText,G__setup_memfuncTEveText);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTextEditor),sizeof(TEveTextEditor),-1,327424,"GUI editor for TEveText.",G__setup_memvarTEveTextEditor,G__setup_memfuncTEveTextEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTextGL),sizeof(TEveTextGL),-1,298752,"GL renderer class for TEveText.",G__setup_memvarTEveTextGL,G__setup_memfuncTEveTextGL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTrackPropagatorSubEditor),sizeof(TEveTrackPropagatorSubEditor),-1,327168,"Sub-editor for TEveTrackPropagator class.",G__setup_memvarTEveTrackPropagatorSubEditor,G__setup_memfuncTEveTrackPropagatorSubEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTrack),sizeof(TEveTrack),-1,327424,"Track with given vertex, momentum and optional referece-points (path-marks) along its path.",G__setup_memvarTEveTrack,G__setup_memfuncTEveTrack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTrackList),sizeof(TEveTrackList),-1,327424,"A list of tracks supporting change of common attributes and selection based on track parameters.",G__setup_memvarTEveTrackList,G__setup_memfuncTEveTrackList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTrackEditor),sizeof(TEveTrackEditor),-1,327424,"Editor for TEveTrack class.",G__setup_memvarTEveTrackEditor,G__setup_memfuncTEveTrackEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTrackListEditor),sizeof(TEveTrackListEditor),-1,327424,"Editor for TEveTrackList class.",G__setup_memvarTEveTrackListEditor,G__setup_memfuncTEveTrackListEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTrackGL),sizeof(TEveTrackGL),-1,298752,"GL-renderer for TEveTrack class.",G__setup_memvarTEveTrackGL,G__setup_memfuncTEveTrackGL);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEvePathMarkTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEvePathMarkTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TMarker);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTrackPropagator),sizeof(TEveTrackPropagator),-1,327424,"Calculates path of a particle taking into account special path-marks and imposed boundaries.",G__setup_memvarTEveTrackPropagator,G__setup_memfuncTEveTrackPropagator);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveRecTrack);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveMCTrack);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TParticle);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlETEvePathMarkTlEfloatgRcOallocatorlETEvePathMarkTlEfloatgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTrackcLcLEBreakProjectedTracks_e);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTrackProjected),sizeof(TEveTrackProjected),-1,327424,"Projected copy of a TEveTrack.",G__setup_memvarTEveTrackProjected,G__setup_memfuncTEveTrackProjected);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTrackProjectedGL),sizeof(TEveTrackProjectedGL),-1,298752,"GL-renderer for TEveTrackProjected class.",G__setup_memvarTEveTrackProjectedGL,G__setup_memfuncTEveTrackProjectedGL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTrackListProjected),sizeof(TEveTrackListProjected),-1,327424,"Specialization of TEveTrackList for holding TEveTrackProjected objects.",G__setup_memvarTEveTrackListProjected,G__setup_memfuncTEveTrackListProjected);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TAttMarkerEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTrackPropagatorEditor),sizeof(TEveTrackPropagatorEditor),-1,327424,"Editor for TEveTrackPropagator class.",G__setup_memvarTEveTrackPropagatorEditor,G__setup_memfuncTEveTrackPropagatorEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveMagField),sizeof(TEveMagField),-1,263425,"Abstract interface to magnetic field",G__setup_memvarTEveMagField,G__setup_memfuncTEveMagField);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveMagFieldConst),sizeof(TEveMagFieldConst),-1,295936,"Interface to constant magnetic field.",G__setup_memvarTEveMagFieldConst,G__setup_memfuncTEveMagFieldConst);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveMagFieldDuo),sizeof(TEveMagFieldDuo),-1,295936,"Interface to magnetic field with two different values depending of radius.",G__setup_memvarTEveMagFieldDuo,G__setup_memfuncTEveMagFieldDuo);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTrackPropagatorcLcLHelix_t);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTrackPropagatorcLcLEStepper_e);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTrackPropagatorcLcLEProjTrackBreaking_e);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETEveVector4TlEfloatgRcOallocatorlETEveVector4TlEfloatgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveVector4TlEfloatgRcOallocatorlETEveVector4TlEfloatgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTriangleSet),sizeof(TEveTriangleSet),-1,327168,"Generic mesh or soup of triangles with per-triangle normals and colors.",G__setup_memvarTEveTriangleSet,G__setup_memfuncTEveTriangleSet);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTriangleSetEditor),sizeof(TEveTriangleSetEditor),-1,327424,"Editor for TEveTriangleSet class.",G__setup_memvarTEveTriangleSetEditor,G__setup_memfuncTEveTriangleSetEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveTriangleSetGL),sizeof(TEveTriangleSetGL),-1,298752,"GL-renderer for TEveTriangleSet class.",G__setup_memvarTEveTriangleSetGL,G__setup_memfuncTEveTriangleSetGL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveJetCone),sizeof(TEveJetCone),-1,327424,"Short description.",G__setup_memvarTEveJetCone,G__setup_memfuncTEveJetCone);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveJetConeEditor),sizeof(TEveJetConeEditor),-1,327424,"GUI editor for TEveJetCone.",G__setup_memvarTEveJetConeEditor,G__setup_memfuncTEveJetConeEditor);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveJetConeProjected),sizeof(TEveJetConeProjected),-1,327424,"Projection of TEveJetCone.",G__setup_memvarTEveJetConeProjected,G__setup_memfuncTEveJetConeProjected);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveJetConeGL),sizeof(TEveJetConeGL),-1,298752,"GL renderer class for TEveJetCone.",G__setup_memvarTEveJetConeGL,G__setup_memfuncTEveJetConeGL);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_vectorlETEveVectorTlEfloatgRcOallocatorlETEveVectorTlEfloatgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_reverse_iteratorlEvectorlETEveVectorTlEfloatgRcOallocatorlETEveVectorTlEfloatgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEveJetConeProjectedGL),sizeof(TEveJetConeProjectedGL),-1,298752,"GL renderer class for TEveJetCone.",G__setup_memvarTEveJetConeProjectedGL,G__setup_memfuncTEveJetConeProjectedGL);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEvePlot3D),sizeof(TEvePlot3D),-1,327424,"Short description.",G__setup_memvarTEvePlot3D,G__setup_memfuncTEvePlot3D);
   G__get_linked_tagnum_fwd(&G__G__Eve2LN_TGLPlot3D);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Eve2LN_TEvePlot3DGL),sizeof(TEvePlot3DGL),-1,298752,"GL renderer class for TEvePlot3D.",G__setup_memvarTEvePlot3DGL,G__setup_memfuncTEvePlot3DGL);
}
extern "C" void G__cpp_setupG__Eve2(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Eve2()");
  G__set_cpp_environmentG__Eve2();
  G__cpp_setup_tagtableG__Eve2();

  G__cpp_setup_inheritanceG__Eve2();

  G__cpp_setup_typetableG__Eve2();

  G__cpp_setup_memvarG__Eve2();

  G__cpp_setup_memfuncG__Eve2();
  G__cpp_setup_globalG__Eve2();
  G__cpp_setup_funcG__Eve2();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Eve2();
  return;
}
class G__cpp_setup_initG__Eve2 {
  public:
    G__cpp_setup_initG__Eve2() { G__add_setup_func("G__Eve2",(G__incsetup)(&G__cpp_setupG__Eve2)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Eve2() { G__remove_setup_func("G__Eve2"); }
};
G__cpp_setup_initG__Eve2 G__cpp_setup_initializerG__Eve2;

---