G__Geom1.cxx

Go to the documentation of this file.

//
// File generated by core/utils/src/rootcint_tmp at Wed Apr 20 13:44:01 2011

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

#define R__DICTIONARY_FILENAME geomdIgeomdIsrcdIG__Geom1
#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__Geom1.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 TGeoAtt_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoAtt(void *p = 0);
   static void *newArray_TGeoAtt(Long_t size, void *p);
   static void delete_TGeoAtt(void *p);
   static void deleteArray_TGeoAtt(void *p);
   static void destruct_TGeoAtt(void *p);

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

namespace ROOT {
   void TGeoShape_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoShape(void *p);
   static void deleteArray_TGeoShape(void *p);
   static void destruct_TGeoShape(void *p);

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

namespace ROOT {
   void TGeoMatrix_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoMatrix(void *p);
   static void deleteArray_TGeoMatrix(void *p);
   static void destruct_TGeoMatrix(void *p);

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

namespace ROOT {
   void TGeoHMatrix_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoHMatrix(void *p = 0);
   static void *newArray_TGeoHMatrix(Long_t size, void *p);
   static void delete_TGeoHMatrix(void *p);
   static void deleteArray_TGeoHMatrix(void *p);
   static void destruct_TGeoHMatrix(void *p);

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

namespace ROOT {
   void TGeoBoolNode_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoBoolNode(void *p);
   static void deleteArray_TGeoBoolNode(void *p);
   static void destruct_TGeoBoolNode(void *p);

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

namespace ROOT {
   void TGeoUnion_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoUnion(void *p = 0);
   static void *newArray_TGeoUnion(Long_t size, void *p);
   static void delete_TGeoUnion(void *p);
   static void deleteArray_TGeoUnion(void *p);
   static void destruct_TGeoUnion(void *p);

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

namespace ROOT {
   void TGeoIntersection_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoIntersection(void *p = 0);
   static void *newArray_TGeoIntersection(Long_t size, void *p);
   static void delete_TGeoIntersection(void *p);
   static void deleteArray_TGeoIntersection(void *p);
   static void destruct_TGeoIntersection(void *p);

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

namespace ROOT {
   void TGeoSubtraction_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoSubtraction(void *p = 0);
   static void *newArray_TGeoSubtraction(Long_t size, void *p);
   static void delete_TGeoSubtraction(void *p);
   static void deleteArray_TGeoSubtraction(void *p);
   static void destruct_TGeoSubtraction(void *p);

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

namespace ROOT {
   void TGeoElementTable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoElementTable(void *p = 0);
   static void *newArray_TGeoElementTable(Long_t size, void *p);
   static void delete_TGeoElementTable(void *p);
   static void deleteArray_TGeoElementTable(void *p);
   static void destruct_TGeoElementTable(void *p);

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

namespace ROOT {
   void TGeoIsotope_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoIsotope(void *p = 0);
   static void *newArray_TGeoIsotope(Long_t size, void *p);
   static void delete_TGeoIsotope(void *p);
   static void deleteArray_TGeoIsotope(void *p);
   static void destruct_TGeoIsotope(void *p);

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

namespace ROOT {
   void TGeoElement_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoElement(void *p = 0);
   static void *newArray_TGeoElement(Long_t size, void *p);
   static void delete_TGeoElement(void *p);
   static void deleteArray_TGeoElement(void *p);
   static void destruct_TGeoElement(void *p);

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

namespace ROOT {
   void TGeoDecayChannel_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoDecayChannel(void *p = 0);
   static void *newArray_TGeoDecayChannel(Long_t size, void *p);
   static void delete_TGeoDecayChannel(void *p);
   static void deleteArray_TGeoDecayChannel(void *p);
   static void destruct_TGeoDecayChannel(void *p);

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

namespace ROOT {
   void TGeoBatemanSol_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoBatemanSol(void *p = 0);
   static void *newArray_TGeoBatemanSol(Long_t size, void *p);
   static void delete_TGeoBatemanSol(void *p);
   static void deleteArray_TGeoBatemanSol(void *p);
   static void destruct_TGeoBatemanSol(void *p);

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

namespace ROOT {
   void TGeoElementRN_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoElementRN(void *p = 0);
   static void *newArray_TGeoElementRN(Long_t size, void *p);
   static void delete_TGeoElementRN(void *p);
   static void deleteArray_TGeoElementRN(void *p);
   static void destruct_TGeoElementRN(void *p);

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

namespace ROOT {
   void TGeoElemIter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoElemIter(void *p);
   static void deleteArray_TGeoElemIter(void *p);
   static void destruct_TGeoElemIter(void *p);

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

namespace ROOT {
   void TGeoMaterial_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoMaterial(void *p = 0);
   static void *newArray_TGeoMaterial(Long_t size, void *p);
   static void delete_TGeoMaterial(void *p);
   static void deleteArray_TGeoMaterial(void *p);
   static void destruct_TGeoMaterial(void *p);

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

namespace ROOT {
   void TGeoMixture_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoMixture(void *p = 0);
   static void *newArray_TGeoMixture(Long_t size, void *p);
   static void delete_TGeoMixture(void *p);
   static void deleteArray_TGeoMixture(void *p);
   static void destruct_TGeoMixture(void *p);

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

namespace ROOT {
   void TGeoMedium_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoMedium(void *p = 0);
   static void *newArray_TGeoMedium(Long_t size, void *p);
   static void delete_TGeoMedium(void *p);
   static void deleteArray_TGeoMedium(void *p);
   static void destruct_TGeoMedium(void *p);

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

namespace ROOT {
   void TGeoTranslation_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoTranslation(void *p = 0);
   static void *newArray_TGeoTranslation(Long_t size, void *p);
   static void delete_TGeoTranslation(void *p);
   static void deleteArray_TGeoTranslation(void *p);
   static void destruct_TGeoTranslation(void *p);

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

namespace ROOT {
   void TGeoRotation_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoRotation(void *p = 0);
   static void *newArray_TGeoRotation(Long_t size, void *p);
   static void delete_TGeoRotation(void *p);
   static void deleteArray_TGeoRotation(void *p);
   static void destruct_TGeoRotation(void *p);

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

namespace ROOT {
   void TGeoScale_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoScale(void *p = 0);
   static void *newArray_TGeoScale(Long_t size, void *p);
   static void delete_TGeoScale(void *p);
   static void deleteArray_TGeoScale(void *p);
   static void destruct_TGeoScale(void *p);

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

namespace ROOT {
   void TGeoCombiTrans_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoCombiTrans(void *p = 0);
   static void *newArray_TGeoCombiTrans(Long_t size, void *p);
   static void delete_TGeoCombiTrans(void *p);
   static void deleteArray_TGeoCombiTrans(void *p);
   static void destruct_TGeoCombiTrans(void *p);

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

namespace ROOT {
   void TGeoGenTrans_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoGenTrans(void *p = 0);
   static void *newArray_TGeoGenTrans(Long_t size, void *p);
   static void delete_TGeoGenTrans(void *p);
   static void deleteArray_TGeoGenTrans(void *p);
   static void destruct_TGeoGenTrans(void *p);

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

namespace ROOT {
   void TGeoIdentity_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoIdentity(void *p = 0);
   static void *newArray_TGeoIdentity(Long_t size, void *p);
   static void delete_TGeoIdentity(void *p);
   static void deleteArray_TGeoIdentity(void *p);
   static void destruct_TGeoIdentity(void *p);

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

namespace ROOT {
   void TGeoBBox_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoBBox(void *p = 0);
   static void *newArray_TGeoBBox(Long_t size, void *p);
   static void delete_TGeoBBox(void *p);
   static void deleteArray_TGeoBBox(void *p);
   static void destruct_TGeoBBox(void *p);

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

namespace ROOT {
   void TGeoVolume_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoVolume(void *p = 0);
   static void *newArray_TGeoVolume(Long_t size, void *p);
   static void delete_TGeoVolume(void *p);
   static void deleteArray_TGeoVolume(void *p);
   static void destruct_TGeoVolume(void *p);
   static void streamer_TGeoVolume(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoVolume*)
   {
      ::TGeoVolume *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoVolume >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TGeoVolume", ::TGeoVolume::Class_Version(), "include/TGeoVolume.h", 65,
                  typeid(::TGeoVolume), DefineBehavior(ptr, ptr),
                  &::TGeoVolume::Dictionary, isa_proxy, 1,
                  sizeof(::TGeoVolume) );
      instance.SetNew(&new_TGeoVolume);
      instance.SetNewArray(&newArray_TGeoVolume);
      instance.SetDelete(&delete_TGeoVolume);
      instance.SetDeleteArray(&deleteArray_TGeoVolume);
      instance.SetDestructor(&destruct_TGeoVolume);
      instance.SetStreamerFunc(&streamer_TGeoVolume);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TGeoVolume*)
   {
      return GenerateInitInstanceLocal((::TGeoVolume*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoVolume*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TGeoNode_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoNode(void *p);
   static void deleteArray_TGeoNode(void *p);
   static void destruct_TGeoNode(void *p);

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

namespace ROOT {
   void TGeoVoxelFinder_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoVoxelFinder(void *p = 0);
   static void *newArray_TGeoVoxelFinder(Long_t size, void *p);
   static void delete_TGeoVoxelFinder(void *p);
   static void deleteArray_TGeoVoxelFinder(void *p);
   static void destruct_TGeoVoxelFinder(void *p);
   static void streamer_TGeoVoxelFinder(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoManager_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoManager(void *p = 0);
   static void *newArray_TGeoManager(Long_t size, void *p);
   static void delete_TGeoManager(void *p);
   static void deleteArray_TGeoManager(void *p);
   static void destruct_TGeoManager(void *p);
   static void streamer_TGeoManager(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoVolumeMulti_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoVolumeMulti(void *p = 0);
   static void *newArray_TGeoVolumeMulti(Long_t size, void *p);
   static void delete_TGeoVolumeMulti(void *p);
   static void deleteArray_TGeoVolumeMulti(void *p);
   static void destruct_TGeoVolumeMulti(void *p);

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

namespace ROOT {
   void TGeoVolumeAssembly_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoVolumeAssembly(void *p = 0);
   static void *newArray_TGeoVolumeAssembly(Long_t size, void *p);
   static void delete_TGeoVolumeAssembly(void *p);
   static void deleteArray_TGeoVolumeAssembly(void *p);
   static void destruct_TGeoVolumeAssembly(void *p);

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

namespace ROOT {
   void TGeoNodeMatrix_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoNodeMatrix(void *p = 0);
   static void *newArray_TGeoNodeMatrix(Long_t size, void *p);
   static void delete_TGeoNodeMatrix(void *p);
   static void deleteArray_TGeoNodeMatrix(void *p);
   static void destruct_TGeoNodeMatrix(void *p);

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

namespace ROOT {
   void TGeoNodeOffset_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoNodeOffset(void *p = 0);
   static void *newArray_TGeoNodeOffset(Long_t size, void *p);
   static void delete_TGeoNodeOffset(void *p);
   static void deleteArray_TGeoNodeOffset(void *p);
   static void destruct_TGeoNodeOffset(void *p);

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

namespace ROOT {
   void TGeoIterator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoIterator(void *p);
   static void deleteArray_TGeoIterator(void *p);
   static void destruct_TGeoIterator(void *p);
   static void streamer_TGeoIterator(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoIteratorPlugin_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoIteratorPlugin(void *p);
   static void deleteArray_TGeoIteratorPlugin(void *p);
   static void destruct_TGeoIteratorPlugin(void *p);
   static void streamer_TGeoIteratorPlugin(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoPara_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoPara(void *p = 0);
   static void *newArray_TGeoPara(Long_t size, void *p);
   static void delete_TGeoPara(void *p);
   static void deleteArray_TGeoPara(void *p);
   static void destruct_TGeoPara(void *p);

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

namespace ROOT {
   void TGeoTube_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoTube(void *p = 0);
   static void *newArray_TGeoTube(Long_t size, void *p);
   static void delete_TGeoTube(void *p);
   static void deleteArray_TGeoTube(void *p);
   static void destruct_TGeoTube(void *p);

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

namespace ROOT {
   void TGeoTubeSeg_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoTubeSeg(void *p = 0);
   static void *newArray_TGeoTubeSeg(Long_t size, void *p);
   static void delete_TGeoTubeSeg(void *p);
   static void deleteArray_TGeoTubeSeg(void *p);
   static void destruct_TGeoTubeSeg(void *p);

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

namespace ROOT {
   void TGeoCtub_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoCtub(void *p = 0);
   static void *newArray_TGeoCtub(Long_t size, void *p);
   static void delete_TGeoCtub(void *p);
   static void deleteArray_TGeoCtub(void *p);
   static void destruct_TGeoCtub(void *p);

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

namespace ROOT {
   void TGeoTorus_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoTorus(void *p = 0);
   static void *newArray_TGeoTorus(Long_t size, void *p);
   static void delete_TGeoTorus(void *p);
   static void deleteArray_TGeoTorus(void *p);
   static void destruct_TGeoTorus(void *p);

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

namespace ROOT {
   void TGeoSphere_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoSphere(void *p = 0);
   static void *newArray_TGeoSphere(Long_t size, void *p);
   static void delete_TGeoSphere(void *p);
   static void deleteArray_TGeoSphere(void *p);
   static void destruct_TGeoSphere(void *p);

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

namespace ROOT {
   void TGeoEltu_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoEltu(void *p = 0);
   static void *newArray_TGeoEltu(Long_t size, void *p);
   static void delete_TGeoEltu(void *p);
   static void deleteArray_TGeoEltu(void *p);
   static void destruct_TGeoEltu(void *p);

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

namespace ROOT {
   void TGeoHype_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoHype(void *p = 0);
   static void *newArray_TGeoHype(Long_t size, void *p);
   static void delete_TGeoHype(void *p);
   static void deleteArray_TGeoHype(void *p);
   static void destruct_TGeoHype(void *p);

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

namespace ROOT {
   void TGeoCone_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoCone(void *p = 0);
   static void *newArray_TGeoCone(Long_t size, void *p);
   static void delete_TGeoCone(void *p);
   static void deleteArray_TGeoCone(void *p);
   static void destruct_TGeoCone(void *p);

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

namespace ROOT {
   void TGeoConeSeg_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoConeSeg(void *p = 0);
   static void *newArray_TGeoConeSeg(Long_t size, void *p);
   static void delete_TGeoConeSeg(void *p);
   static void deleteArray_TGeoConeSeg(void *p);
   static void destruct_TGeoConeSeg(void *p);

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

namespace ROOT {
   void TGeoPcon_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoPcon(void *p = 0);
   static void *newArray_TGeoPcon(Long_t size, void *p);
   static void delete_TGeoPcon(void *p);
   static void deleteArray_TGeoPcon(void *p);
   static void destruct_TGeoPcon(void *p);

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

namespace ROOT {
   void TGeoPgon_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoPgon(void *p = 0);
   static void *newArray_TGeoPgon(Long_t size, void *p);
   static void delete_TGeoPgon(void *p);
   static void deleteArray_TGeoPgon(void *p);
   static void destruct_TGeoPgon(void *p);

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

namespace ROOT {
   void TGeoArb8_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoArb8(void *p = 0);
   static void *newArray_TGeoArb8(Long_t size, void *p);
   static void delete_TGeoArb8(void *p);
   static void deleteArray_TGeoArb8(void *p);
   static void destruct_TGeoArb8(void *p);
   static void streamer_TGeoArb8(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoTrap_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoTrap(void *p = 0);
   static void *newArray_TGeoTrap(Long_t size, void *p);
   static void delete_TGeoTrap(void *p);
   static void deleteArray_TGeoTrap(void *p);
   static void destruct_TGeoTrap(void *p);

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

namespace ROOT {
   void TGeoGtra_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoGtra(void *p = 0);
   static void *newArray_TGeoGtra(Long_t size, void *p);
   static void delete_TGeoGtra(void *p);
   static void deleteArray_TGeoGtra(void *p);
   static void destruct_TGeoGtra(void *p);

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

namespace ROOT {
   void TGeoTrd1_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoTrd1(void *p = 0);
   static void *newArray_TGeoTrd1(Long_t size, void *p);
   static void delete_TGeoTrd1(void *p);
   static void deleteArray_TGeoTrd1(void *p);
   static void destruct_TGeoTrd1(void *p);

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

namespace ROOT {
   void TGeoTrd2_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoTrd2(void *p = 0);
   static void *newArray_TGeoTrd2(Long_t size, void *p);
   static void delete_TGeoTrd2(void *p);
   static void deleteArray_TGeoTrd2(void *p);
   static void destruct_TGeoTrd2(void *p);

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

namespace ROOT {
   void TGeoNavigator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoNavigator(void *p = 0);
   static void *newArray_TGeoNavigator(Long_t size, void *p);
   static void delete_TGeoNavigator(void *p);
   static void deleteArray_TGeoNavigator(void *p);
   static void destruct_TGeoNavigator(void *p);

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

namespace ROOT {
   void TVirtualGeoTrack_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVirtualGeoTrack(void *p);
   static void deleteArray_TVirtualGeoTrack(void *p);
   static void destruct_TVirtualGeoTrack(void *p);

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

namespace ROOT {
   void TGeoPhysicalNode_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoPhysicalNode(void *p = 0);
   static void *newArray_TGeoPhysicalNode(Long_t size, void *p);
   static void delete_TGeoPhysicalNode(void *p);
   static void deleteArray_TGeoPhysicalNode(void *p);
   static void destruct_TGeoPhysicalNode(void *p);

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

namespace ROOT {
   void TGeoPNEntry_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoPNEntry(void *p = 0);
   static void *newArray_TGeoPNEntry(Long_t size, void *p);
   static void delete_TGeoPNEntry(void *p);
   static void deleteArray_TGeoPNEntry(void *p);
   static void destruct_TGeoPNEntry(void *p);

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

namespace ROOT {
   void TVirtualGeoPainter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TVirtualGeoPainter(void *p);
   static void deleteArray_TVirtualGeoPainter(void *p);
   static void destruct_TVirtualGeoPainter(void *p);

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

namespace ROOT {
   void TGeoCompositeShape_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoCompositeShape(void *p = 0);
   static void *newArray_TGeoCompositeShape(Long_t size, void *p);
   static void delete_TGeoCompositeShape(void *p);
   static void deleteArray_TGeoCompositeShape(void *p);
   static void destruct_TGeoCompositeShape(void *p);

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

namespace ROOT {
   void TGeoShapeAssembly_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoShapeAssembly(void *p = 0);
   static void *newArray_TGeoShapeAssembly(Long_t size, void *p);
   static void delete_TGeoShapeAssembly(void *p);
   static void deleteArray_TGeoShapeAssembly(void *p);
   static void destruct_TGeoShapeAssembly(void *p);

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

namespace ROOT {
   void TGeoScaledShape_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoScaledShape(void *p = 0);
   static void *newArray_TGeoScaledShape(Long_t size, void *p);
   static void delete_TGeoScaledShape(void *p);
   static void deleteArray_TGeoScaledShape(void *p);
   static void destruct_TGeoScaledShape(void *p);

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

namespace ROOT {
   void TGeoPolygon_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoPolygon(void *p = 0);
   static void *newArray_TGeoPolygon(Long_t size, void *p);
   static void delete_TGeoPolygon(void *p);
   static void deleteArray_TGeoPolygon(void *p);
   static void destruct_TGeoPolygon(void *p);

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

namespace ROOT {
   void TGeoXtru_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoXtru(void *p = 0);
   static void *newArray_TGeoXtru(Long_t size, void *p);
   static void delete_TGeoXtru(void *p);
   static void deleteArray_TGeoXtru(void *p);
   static void destruct_TGeoXtru(void *p);
   static void streamer_TGeoXtru(TBuffer &buf, void *obj);

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

namespace ROOT {
   void TGeoHelix_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoHelix(void *p = 0);
   static void *newArray_TGeoHelix(Long_t size, void *p);
   static void delete_TGeoHelix(void *p);
   static void deleteArray_TGeoHelix(void *p);
   static void destruct_TGeoHelix(void *p);

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

namespace ROOT {
   void TGeoParaboloid_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoParaboloid(void *p = 0);
   static void *newArray_TGeoParaboloid(Long_t size, void *p);
   static void delete_TGeoParaboloid(void *p);
   static void deleteArray_TGeoParaboloid(void *p);
   static void destruct_TGeoParaboloid(void *p);

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

namespace ROOT {
   void TGeoHalfSpace_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TGeoHalfSpace(void *p = 0);
   static void *newArray_TGeoHalfSpace(Long_t size, void *p);
   static void delete_TGeoHalfSpace(void *p);
   static void deleteArray_TGeoHalfSpace(void *p);
   static void destruct_TGeoHalfSpace(void *p);

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

namespace ROOT {
   void TGeoBuilder_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TGeoBuilder(void *p);
   static void deleteArray_TGeoBuilder(void *p);
   static void destruct_TGeoBuilder(void *p);
   static void streamer_TGeoBuilder(TBuffer &buf, void *obj);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoAtt(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGeoAtt : new ::TGeoAtt;
   }
   static void *newArray_TGeoAtt(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TGeoAtt[nElements] : new ::TGeoAtt[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoAtt(void *p) {
      delete ((::TGeoAtt*)p);
   }
   static void deleteArray_TGeoAtt(void *p) {
      delete [] ((::TGeoAtt*)p);
   }
   static void destruct_TGeoAtt(void *p) {
      typedef ::TGeoAtt current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoAtt

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

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

//______________________________________________________________________________
void TGeoBoolNode::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoBoolNode.
      TClass *R__cl = ::TGeoBoolNode::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelected", &fSelected);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLeft", &fLeft);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRight", &fRight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLeftMat", &fLeftMat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRightMat", &fRightMat);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpoints", &fNpoints);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPoints", &fPoints);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGeoBoolNode(void *p) {
      delete ((::TGeoBoolNode*)p);
   }
   static void deleteArray_TGeoBoolNode(void *p) {
      delete [] ((::TGeoBoolNode*)p);
   }
   static void destruct_TGeoBoolNode(void *p) {
      typedef ::TGeoBoolNode current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoBoolNode

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoUnion(void *p) {
      return  p ? new(p) ::TGeoUnion : new ::TGeoUnion;
   }
   static void *newArray_TGeoUnion(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoUnion[nElements] : new ::TGeoUnion[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoUnion(void *p) {
      delete ((::TGeoUnion*)p);
   }
   static void deleteArray_TGeoUnion(void *p) {
      delete [] ((::TGeoUnion*)p);
   }
   static void destruct_TGeoUnion(void *p) {
      typedef ::TGeoUnion current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoUnion

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoIntersection(void *p) {
      return  p ? new(p) ::TGeoIntersection : new ::TGeoIntersection;
   }
   static void *newArray_TGeoIntersection(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoIntersection[nElements] : new ::TGeoIntersection[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoIntersection(void *p) {
      delete ((::TGeoIntersection*)p);
   }
   static void deleteArray_TGeoIntersection(void *p) {
      delete [] ((::TGeoIntersection*)p);
   }
   static void destruct_TGeoIntersection(void *p) {
      typedef ::TGeoIntersection current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoIntersection

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoSubtraction(void *p) {
      return  p ? new(p) ::TGeoSubtraction : new ::TGeoSubtraction;
   }
   static void *newArray_TGeoSubtraction(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoSubtraction[nElements] : new ::TGeoSubtraction[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoSubtraction(void *p) {
      delete ((::TGeoSubtraction*)p);
   }
   static void deleteArray_TGeoSubtraction(void *p) {
      delete [] ((::TGeoSubtraction*)p);
   }
   static void destruct_TGeoSubtraction(void *p) {
      typedef ::TGeoSubtraction current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoSubtraction

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoMedium(void *p) {
      return  p ? new(p) ::TGeoMedium : new ::TGeoMedium;
   }
   static void *newArray_TGeoMedium(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoMedium[nElements] : new ::TGeoMedium[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoMedium(void *p) {
      delete ((::TGeoMedium*)p);
   }
   static void deleteArray_TGeoMedium(void *p) {
      delete [] ((::TGeoMedium*)p);
   }
   static void destruct_TGeoMedium(void *p) {
      typedef ::TGeoMedium current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoMedium

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

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

//______________________________________________________________________________
void TGeoElement::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoElement.
      TClass *R__cl = ::TGeoElement::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ", &fZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fN", &fN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNisotopes", &fNisotopes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fA", &fA);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIsotopes", &fIsotopes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAbundances", &fAbundances);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoElement(void *p) {
      return  p ? new(p) ::TGeoElement : new ::TGeoElement;
   }
   static void *newArray_TGeoElement(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoElement[nElements] : new ::TGeoElement[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoElement(void *p) {
      delete ((::TGeoElement*)p);
   }
   static void deleteArray_TGeoElement(void *p) {
      delete [] ((::TGeoElement*)p);
   }
   static void destruct_TGeoElement(void *p) {
      typedef ::TGeoElement current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoElement

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

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

//______________________________________________________________________________
void TGeoElementRN::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoElementRN.
      TClass *R__cl = ::TGeoElementRN::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fENDFcode", &fENDFcode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIso", &fIso);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLevel", &fLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDeltaM", &fDeltaM);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHalfLife", &fHalfLife);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNatAbun", &fNatAbun);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTH_F", &fTH_F);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTG_F", &fTG_F);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTH_S", &fTH_S);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTG_S", &fTG_S);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &fStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRatio", &fRatio);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDecays", &fDecays);
      TGeoElement::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoElementRN(void *p) {
      return  p ? new(p) ::TGeoElementRN : new ::TGeoElementRN;
   }
   static void *newArray_TGeoElementRN(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoElementRN[nElements] : new ::TGeoElementRN[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoElementRN(void *p) {
      delete ((::TGeoElementRN*)p);
   }
   static void deleteArray_TGeoElementRN(void *p) {
      delete [] ((::TGeoElementRN*)p);
   }
   static void destruct_TGeoElementRN(void *p) {
      typedef ::TGeoElementRN current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoElementRN

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoIsotope(void *p) {
      return  p ? new(p) ::TGeoIsotope : new ::TGeoIsotope;
   }
   static void *newArray_TGeoIsotope(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoIsotope[nElements] : new ::TGeoIsotope[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoIsotope(void *p) {
      delete ((::TGeoIsotope*)p);
   }
   static void deleteArray_TGeoIsotope(void *p) {
      delete [] ((::TGeoIsotope*)p);
   }
   static void destruct_TGeoIsotope(void *p) {
      typedef ::TGeoIsotope current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoIsotope

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

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

//______________________________________________________________________________
void TGeoDecayChannel::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoDecayChannel.
      TClass *R__cl = ::TGeoDecayChannel::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDecay", &fDecay);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDiso", &fDiso);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBranchingRatio", &fBranchingRatio);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQvalue", &fQvalue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParent", &fParent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDaughter", &fDaughter);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoDecayChannel(void *p) {
      return  p ? new(p) ::TGeoDecayChannel : new ::TGeoDecayChannel;
   }
   static void *newArray_TGeoDecayChannel(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoDecayChannel[nElements] : new ::TGeoDecayChannel[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoDecayChannel(void *p) {
      delete ((::TGeoDecayChannel*)p);
   }
   static void deleteArray_TGeoDecayChannel(void *p) {
      delete [] ((::TGeoDecayChannel*)p);
   }
   static void destruct_TGeoDecayChannel(void *p) {
      typedef ::TGeoDecayChannel current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoDecayChannel

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

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

//______________________________________________________________________________
void TGeoElemIter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoElemIter.
      TClass *R__cl = ::TGeoElemIter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTop", &fTop);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElem", &fElem);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBranch", &fBranch);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLevel", &fLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLimitRatio", &fLimitRatio);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRatio", &fRatio);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGeoElemIter(void *p) {
      delete ((::TGeoElemIter*)p);
   }
   static void deleteArray_TGeoElemIter(void *p) {
      delete [] ((::TGeoElemIter*)p);
   }
   static void destruct_TGeoElemIter(void *p) {
      typedef ::TGeoElemIter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoElemIter

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

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

//______________________________________________________________________________
void TGeoBatemanSol::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoBatemanSol.
      TClass *R__cl = ::TGeoBatemanSol::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElem", &fElem);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElemTop", &fElemTop);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCsize", &fCsize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNcoeff", &fNcoeff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFactor", &fFactor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTmin", &fTmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTmax", &fTmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCoeff", &fCoeff);
      TObject::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
      TAttFill::ShowMembers(R__insp);
      TAttMarker::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoBatemanSol(void *p) {
      return  p ? new(p) ::TGeoBatemanSol : new ::TGeoBatemanSol;
   }
   static void *newArray_TGeoBatemanSol(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoBatemanSol[nElements] : new ::TGeoBatemanSol[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoBatemanSol(void *p) {
      delete ((::TGeoBatemanSol*)p);
   }
   static void deleteArray_TGeoBatemanSol(void *p) {
      delete [] ((::TGeoBatemanSol*)p);
   }
   static void destruct_TGeoBatemanSol(void *p) {
      typedef ::TGeoBatemanSol current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoBatemanSol

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

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

//______________________________________________________________________________
void TGeoElementTable::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoElementTable.
      TClass *R__cl = ::TGeoElementTable::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNelements", &fNelements);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNelementsRN", &fNelementsRN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNisotopes", &fNisotopes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fList", &fList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListRN", &fListRN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIsotopes", &fIsotopes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fElementsRN", (void*)&fElementsRN);
      R__insp.InspectMember("TGeoElementTable::ElementRNMap_t", (void*)&fElementsRN, "fElementsRN.", true);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoElementTable(void *p) {
      return  p ? new(p) ::TGeoElementTable : new ::TGeoElementTable;
   }
   static void *newArray_TGeoElementTable(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoElementTable[nElements] : new ::TGeoElementTable[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoElementTable(void *p) {
      delete ((::TGeoElementTable*)p);
   }
   static void deleteArray_TGeoElementTable(void *p) {
      delete [] ((::TGeoElementTable*)p);
   }
   static void destruct_TGeoElementTable(void *p) {
      typedef ::TGeoElementTable current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoElementTable

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

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

//______________________________________________________________________________
void TGeoMaterial::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoMaterial.
      TClass *R__cl = ::TGeoMaterial::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIndex", &fIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fA", &fA);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ", &fZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDensity", &fDensity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRadLen", &fRadLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIntLen", &fIntLen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTemperature", &fTemperature);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPressure", &fPressure);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fState", &fState);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShader", &fShader);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCerenkov", &fCerenkov);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElement", &fElement);
      TNamed::ShowMembers(R__insp);
      TAttFill::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoMaterial(void *p) {
      return  p ? new(p) ::TGeoMaterial : new ::TGeoMaterial;
   }
   static void *newArray_TGeoMaterial(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoMaterial[nElements] : new ::TGeoMaterial[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoMaterial(void *p) {
      delete ((::TGeoMaterial*)p);
   }
   static void deleteArray_TGeoMaterial(void *p) {
      delete [] ((::TGeoMaterial*)p);
   }
   static void destruct_TGeoMaterial(void *p) {
      typedef ::TGeoMaterial current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoMaterial

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

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

//______________________________________________________________________________
void TGeoMixture::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoMixture.
      TClass *R__cl = ::TGeoMixture::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNelements", &fNelements);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZmixture", &fZmixture);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAmixture", &fAmixture);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWeights", &fWeights);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNatoms", &fNatoms);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElements", &fElements);
      TGeoMaterial::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoMixture(void *p) {
      return  p ? new(p) ::TGeoMixture : new ::TGeoMixture;
   }
   static void *newArray_TGeoMixture(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoMixture[nElements] : new ::TGeoMixture[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoMixture(void *p) {
      delete ((::TGeoMixture*)p);
   }
   static void deleteArray_TGeoMixture(void *p) {
      delete [] ((::TGeoMixture*)p);
   }
   static void destruct_TGeoMixture(void *p) {
      typedef ::TGeoMixture current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoMixture

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGeoMatrix(void *p) {
      delete ((::TGeoMatrix*)p);
   }
   static void deleteArray_TGeoMatrix(void *p) {
      delete [] ((::TGeoMatrix*)p);
   }
   static void destruct_TGeoMatrix(void *p) {
      typedef ::TGeoMatrix current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoMatrix

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

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

//______________________________________________________________________________
void TGeoHMatrix::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoHMatrix.
      TClass *R__cl = ::TGeoHMatrix::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTranslation[3]", fTranslation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRotationMatrix[9]", fRotationMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScale[3]", fScale);
      TGeoMatrix::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoHMatrix(void *p) {
      return  p ? new(p) ::TGeoHMatrix : new ::TGeoHMatrix;
   }
   static void *newArray_TGeoHMatrix(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoHMatrix[nElements] : new ::TGeoHMatrix[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoHMatrix(void *p) {
      delete ((::TGeoHMatrix*)p);
   }
   static void deleteArray_TGeoHMatrix(void *p) {
      delete [] ((::TGeoHMatrix*)p);
   }
   static void destruct_TGeoHMatrix(void *p) {
      typedef ::TGeoHMatrix current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoHMatrix

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoTranslation(void *p) {
      return  p ? new(p) ::TGeoTranslation : new ::TGeoTranslation;
   }
   static void *newArray_TGeoTranslation(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoTranslation[nElements] : new ::TGeoTranslation[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoTranslation(void *p) {
      delete ((::TGeoTranslation*)p);
   }
   static void deleteArray_TGeoTranslation(void *p) {
      delete [] ((::TGeoTranslation*)p);
   }
   static void destruct_TGeoTranslation(void *p) {
      typedef ::TGeoTranslation current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoTranslation

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoRotation(void *p) {
      return  p ? new(p) ::TGeoRotation : new ::TGeoRotation;
   }
   static void *newArray_TGeoRotation(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoRotation[nElements] : new ::TGeoRotation[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoRotation(void *p) {
      delete ((::TGeoRotation*)p);
   }
   static void deleteArray_TGeoRotation(void *p) {
      delete [] ((::TGeoRotation*)p);
   }
   static void destruct_TGeoRotation(void *p) {
      typedef ::TGeoRotation current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoRotation

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

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

//______________________________________________________________________________
void TGeoCombiTrans::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoCombiTrans.
      TClass *R__cl = ::TGeoCombiTrans::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTranslation[3]", fTranslation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotation", &fRotation);
      TGeoMatrix::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoCombiTrans(void *p) {
      return  p ? new(p) ::TGeoCombiTrans : new ::TGeoCombiTrans;
   }
   static void *newArray_TGeoCombiTrans(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoCombiTrans[nElements] : new ::TGeoCombiTrans[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoCombiTrans(void *p) {
      delete ((::TGeoCombiTrans*)p);
   }
   static void deleteArray_TGeoCombiTrans(void *p) {
      delete [] ((::TGeoCombiTrans*)p);
   }
   static void destruct_TGeoCombiTrans(void *p) {
      typedef ::TGeoCombiTrans current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoCombiTrans

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoGenTrans(void *p) {
      return  p ? new(p) ::TGeoGenTrans : new ::TGeoGenTrans;
   }
   static void *newArray_TGeoGenTrans(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoGenTrans[nElements] : new ::TGeoGenTrans[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoGenTrans(void *p) {
      delete ((::TGeoGenTrans*)p);
   }
   static void deleteArray_TGeoGenTrans(void *p) {
      delete [] ((::TGeoGenTrans*)p);
   }
   static void destruct_TGeoGenTrans(void *p) {
      typedef ::TGeoGenTrans current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoGenTrans

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoScale(void *p) {
      return  p ? new(p) ::TGeoScale : new ::TGeoScale;
   }
   static void *newArray_TGeoScale(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoScale[nElements] : new ::TGeoScale[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoScale(void *p) {
      delete ((::TGeoScale*)p);
   }
   static void deleteArray_TGeoScale(void *p) {
      delete [] ((::TGeoScale*)p);
   }
   static void destruct_TGeoScale(void *p) {
      typedef ::TGeoScale current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoScale

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoIdentity(void *p) {
      return  p ? new(p) ::TGeoIdentity : new ::TGeoIdentity;
   }
   static void *newArray_TGeoIdentity(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoIdentity[nElements] : new ::TGeoIdentity[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoIdentity(void *p) {
      delete ((::TGeoIdentity*)p);
   }
   static void deleteArray_TGeoIdentity(void *p) {
      delete [] ((::TGeoIdentity*)p);
   }
   static void destruct_TGeoIdentity(void *p) {
      typedef ::TGeoIdentity current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoIdentity

//______________________________________________________________________________
void TGeoVoxelFinder::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoVoxelFinder.
      TClass *R__cl = ::TGeoVoxelFinder::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolume", &fVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNcandidates", &fNcandidates);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentVoxel", &fCurrentVoxel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIbx", &fIbx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIby", &fIby);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIbz", &fIbz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNboxes", &fNboxes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNox", &fNox);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNoy", &fNoy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNoz", &fNoz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNex", &fNex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNey", &fNey);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNez", &fNez);
      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(), "fPriority[3]", fPriority);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlices[3]", fSlices);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInc[3]", fInc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInvdir[3]", fInvdir);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLimits[3]", fLimits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxes", &fBoxes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXb", &fXb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYb", &fYb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZb", &fZb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOBx", &fOBx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOBy", &fOBy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOBz", &fOBz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOEx", &fOEx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOEy", &fOEy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOEz", &fOEz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExtraX", &fExtraX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExtraY", &fExtraY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExtraZ", &fExtraZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNsliceX", &fNsliceX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNsliceY", &fNsliceY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNsliceZ", &fNsliceZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIndcX", &fIndcX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIndcY", &fIndcY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIndcZ", &fIndcZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCheckList", &fCheckList);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBits1", &fBits1);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoVoxelFinder(void *p) {
      return  p ? new(p) ::TGeoVoxelFinder : new ::TGeoVoxelFinder;
   }
   static void *newArray_TGeoVoxelFinder(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoVoxelFinder[nElements] : new ::TGeoVoxelFinder[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoVoxelFinder(void *p) {
      delete ((::TGeoVoxelFinder*)p);
   }
   static void deleteArray_TGeoVoxelFinder(void *p) {
      delete [] ((::TGeoVoxelFinder*)p);
   }
   static void destruct_TGeoVoxelFinder(void *p) {
      typedef ::TGeoVoxelFinder current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoVoxelFinder(TBuffer &buf, void *obj) {
      ((::TGeoVoxelFinder*)obj)->::TGeoVoxelFinder::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoVoxelFinder

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGeoShape(void *p) {
      delete ((::TGeoShape*)p);
   }
   static void deleteArray_TGeoShape(void *p) {
      delete [] ((::TGeoShape*)p);
   }
   static void destruct_TGeoShape(void *p) {
      typedef ::TGeoShape current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoShape

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

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

//______________________________________________________________________________
void TGeoHelix::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoHelix.
      TClass *R__cl = ::TGeoHelix::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(), "fS", &fS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStep", &fStep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi", &fPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPointInit[3]", fPointInit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirInit[3]", fDirInit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPoint[3]", fPoint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDir[3]", fDir);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fB[3]", fB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQ", &fQ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &fMatrix);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoHelix(void *p) {
      return  p ? new(p) ::TGeoHelix : new ::TGeoHelix;
   }
   static void *newArray_TGeoHelix(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoHelix[nElements] : new ::TGeoHelix[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoHelix(void *p) {
      delete ((::TGeoHelix*)p);
   }
   static void deleteArray_TGeoHelix(void *p) {
      delete [] ((::TGeoHelix*)p);
   }
   static void destruct_TGeoHelix(void *p) {
      typedef ::TGeoHelix current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoHelix

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

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

//______________________________________________________________________________
void TGeoHalfSpace::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoHalfSpace.
      TClass *R__cl = ::TGeoHalfSpace::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fP[3]", fP);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fN[3]", fN);
      TGeoBBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoHalfSpace(void *p) {
      return  p ? new(p) ::TGeoHalfSpace : new ::TGeoHalfSpace;
   }
   static void *newArray_TGeoHalfSpace(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoHalfSpace[nElements] : new ::TGeoHalfSpace[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoHalfSpace(void *p) {
      delete ((::TGeoHalfSpace*)p);
   }
   static void deleteArray_TGeoHalfSpace(void *p) {
      delete [] ((::TGeoHalfSpace*)p);
   }
   static void destruct_TGeoHalfSpace(void *p) {
      typedef ::TGeoHalfSpace current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoHalfSpace

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

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

//______________________________________________________________________________
void TGeoBBox::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoBBox.
      TClass *R__cl = ::TGeoBBox::IsA();
      if (R__cl || R__insp.IsA()) { }
      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(), "fOrigin[3]", fOrigin);
      TGeoShape::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoBBox(void *p) {
      return  p ? new(p) ::TGeoBBox : new ::TGeoBBox;
   }
   static void *newArray_TGeoBBox(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoBBox[nElements] : new ::TGeoBBox[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoBBox(void *p) {
      delete ((::TGeoBBox*)p);
   }
   static void deleteArray_TGeoBBox(void *p) {
      delete [] ((::TGeoBBox*)p);
   }
   static void destruct_TGeoBBox(void *p) {
      typedef ::TGeoBBox current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoBBox

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

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

//______________________________________________________________________________
void TGeoPara::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoPara.
      TClass *R__cl = ::TGeoPara::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fX", &fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fY", &fY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZ", &fZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlpha", &fAlpha);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta", &fTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi", &fPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTxy", &fTxy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTxz", &fTxz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTyz", &fTyz);
      TGeoBBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoPara(void *p) {
      return  p ? new(p) ::TGeoPara : new ::TGeoPara;
   }
   static void *newArray_TGeoPara(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoPara[nElements] : new ::TGeoPara[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoPara(void *p) {
      delete ((::TGeoPara*)p);
   }
   static void deleteArray_TGeoPara(void *p) {
      delete [] ((::TGeoPara*)p);
   }
   static void destruct_TGeoPara(void *p) {
      typedef ::TGeoPara current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoPara

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

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

//______________________________________________________________________________
void TGeoSphere::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoSphere.
      TClass *R__cl = ::TGeoSphere::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNz", &fNz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNseg", &fNseg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmin", &fRmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmax", &fRmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta1", &fTheta1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta2", &fTheta2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi1", &fPhi1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi2", &fPhi2);
      TGeoBBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoSphere(void *p) {
      return  p ? new(p) ::TGeoSphere : new ::TGeoSphere;
   }
   static void *newArray_TGeoSphere(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoSphere[nElements] : new ::TGeoSphere[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoSphere(void *p) {
      delete ((::TGeoSphere*)p);
   }
   static void deleteArray_TGeoSphere(void *p) {
      delete [] ((::TGeoSphere*)p);
   }
   static void destruct_TGeoSphere(void *p) {
      typedef ::TGeoSphere current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoSphere

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoTube(void *p) {
      return  p ? new(p) ::TGeoTube : new ::TGeoTube;
   }
   static void *newArray_TGeoTube(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoTube[nElements] : new ::TGeoTube[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoTube(void *p) {
      delete ((::TGeoTube*)p);
   }
   static void deleteArray_TGeoTube(void *p) {
      delete [] ((::TGeoTube*)p);
   }
   static void destruct_TGeoTube(void *p) {
      typedef ::TGeoTube current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoTube

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

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

//______________________________________________________________________________
void TGeoTorus::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoTorus.
      TClass *R__cl = ::TGeoTorus::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fR", &fR);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmin", &fRmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmax", &fRmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi1", &fPhi1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDphi", &fDphi);
      TGeoBBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoTorus(void *p) {
      return  p ? new(p) ::TGeoTorus : new ::TGeoTorus;
   }
   static void *newArray_TGeoTorus(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoTorus[nElements] : new ::TGeoTorus[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoTorus(void *p) {
      delete ((::TGeoTorus*)p);
   }
   static void deleteArray_TGeoTorus(void *p) {
      delete [] ((::TGeoTorus*)p);
   }
   static void destruct_TGeoTorus(void *p) {
      typedef ::TGeoTorus current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoTorus

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoTubeSeg(void *p) {
      return  p ? new(p) ::TGeoTubeSeg : new ::TGeoTubeSeg;
   }
   static void *newArray_TGeoTubeSeg(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoTubeSeg[nElements] : new ::TGeoTubeSeg[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoTubeSeg(void *p) {
      delete ((::TGeoTubeSeg*)p);
   }
   static void deleteArray_TGeoTubeSeg(void *p) {
      delete [] ((::TGeoTubeSeg*)p);
   }
   static void destruct_TGeoTubeSeg(void *p) {
      typedef ::TGeoTubeSeg current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoTubeSeg

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

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

//______________________________________________________________________________
void TGeoCtub::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoCtub.
      TClass *R__cl = ::TGeoCtub::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNlow[3]", fNlow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNhigh[3]", fNhigh);
      TGeoTubeSeg::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoCtub(void *p) {
      return  p ? new(p) ::TGeoCtub : new ::TGeoCtub;
   }
   static void *newArray_TGeoCtub(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoCtub[nElements] : new ::TGeoCtub[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoCtub(void *p) {
      delete ((::TGeoCtub*)p);
   }
   static void deleteArray_TGeoCtub(void *p) {
      delete [] ((::TGeoCtub*)p);
   }
   static void destruct_TGeoCtub(void *p) {
      typedef ::TGeoCtub current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoCtub

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoEltu(void *p) {
      return  p ? new(p) ::TGeoEltu : new ::TGeoEltu;
   }
   static void *newArray_TGeoEltu(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoEltu[nElements] : new ::TGeoEltu[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoEltu(void *p) {
      delete ((::TGeoEltu*)p);
   }
   static void deleteArray_TGeoEltu(void *p) {
      delete [] ((::TGeoEltu*)p);
   }
   static void destruct_TGeoEltu(void *p) {
      typedef ::TGeoEltu current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoEltu

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

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

//______________________________________________________________________________
void TGeoHype::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoHype.
      TClass *R__cl = ::TGeoHype::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStIn", &fStIn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStOut", &fStOut);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTin", &fTin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTout", &fTout);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTinsq", &fTinsq);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fToutsq", &fToutsq);
      TGeoTube::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoHype(void *p) {
      return  p ? new(p) ::TGeoHype : new ::TGeoHype;
   }
   static void *newArray_TGeoHype(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoHype[nElements] : new ::TGeoHype[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoHype(void *p) {
      delete ((::TGeoHype*)p);
   }
   static void deleteArray_TGeoHype(void *p) {
      delete [] ((::TGeoHype*)p);
   }
   static void destruct_TGeoHype(void *p) {
      typedef ::TGeoHype current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoHype

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

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

//______________________________________________________________________________
void TGeoCone::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoCone.
      TClass *R__cl = ::TGeoCone::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDz", &fDz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmin1", &fRmin1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmax1", &fRmax1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmin2", &fRmin2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmax2", &fRmax2);
      TGeoBBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoCone(void *p) {
      return  p ? new(p) ::TGeoCone : new ::TGeoCone;
   }
   static void *newArray_TGeoCone(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoCone[nElements] : new ::TGeoCone[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoCone(void *p) {
      delete ((::TGeoCone*)p);
   }
   static void deleteArray_TGeoCone(void *p) {
      delete [] ((::TGeoCone*)p);
   }
   static void destruct_TGeoCone(void *p) {
      typedef ::TGeoCone current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoCone

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoConeSeg(void *p) {
      return  p ? new(p) ::TGeoConeSeg : new ::TGeoConeSeg;
   }
   static void *newArray_TGeoConeSeg(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoConeSeg[nElements] : new ::TGeoConeSeg[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoConeSeg(void *p) {
      delete ((::TGeoConeSeg*)p);
   }
   static void deleteArray_TGeoConeSeg(void *p) {
      delete [] ((::TGeoConeSeg*)p);
   }
   static void destruct_TGeoConeSeg(void *p) {
      typedef ::TGeoConeSeg current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoConeSeg

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

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

//______________________________________________________________________________
void TGeoParaboloid::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoParaboloid.
      TClass *R__cl = ::TGeoParaboloid::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRlo", &fRlo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRhi", &fRhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDz", &fDz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fA", &fA);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fB", &fB);
      TGeoBBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoParaboloid(void *p) {
      return  p ? new(p) ::TGeoParaboloid : new ::TGeoParaboloid;
   }
   static void *newArray_TGeoParaboloid(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoParaboloid[nElements] : new ::TGeoParaboloid[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoParaboloid(void *p) {
      delete ((::TGeoParaboloid*)p);
   }
   static void deleteArray_TGeoParaboloid(void *p) {
      delete [] ((::TGeoParaboloid*)p);
   }
   static void destruct_TGeoParaboloid(void *p) {
      typedef ::TGeoParaboloid current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoParaboloid

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

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

//______________________________________________________________________________
void TGeoPcon::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoPcon.
      TClass *R__cl = ::TGeoPcon::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNz", &fNz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi1", &fPhi1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDphi", &fDphi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRmin", &fRmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRmax", &fRmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZ", &fZ);
      TGeoBBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoPcon(void *p) {
      return  p ? new(p) ::TGeoPcon : new ::TGeoPcon;
   }
   static void *newArray_TGeoPcon(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoPcon[nElements] : new ::TGeoPcon[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoPcon(void *p) {
      delete ((::TGeoPcon*)p);
   }
   static void deleteArray_TGeoPcon(void *p) {
      delete [] ((::TGeoPcon*)p);
   }
   static void destruct_TGeoPcon(void *p) {
      typedef ::TGeoPcon current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoPcon

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoPgon(void *p) {
      return  p ? new(p) ::TGeoPgon : new ::TGeoPgon;
   }
   static void *newArray_TGeoPgon(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoPgon[nElements] : new ::TGeoPgon[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoPgon(void *p) {
      delete ((::TGeoPgon*)p);
   }
   static void deleteArray_TGeoPgon(void *p) {
      delete [] ((::TGeoPgon*)p);
   }
   static void destruct_TGeoPgon(void *p) {
      typedef ::TGeoPgon current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoPgon

//______________________________________________________________________________
void TGeoArb8::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoArb8.
      TClass *R__cl = ::TGeoArb8::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDz", &fDz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTwist", &fTwist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXY[8][2]", fXY);
      TGeoBBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoArb8(void *p) {
      return  p ? new(p) ::TGeoArb8 : new ::TGeoArb8;
   }
   static void *newArray_TGeoArb8(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoArb8[nElements] : new ::TGeoArb8[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoArb8(void *p) {
      delete ((::TGeoArb8*)p);
   }
   static void deleteArray_TGeoArb8(void *p) {
      delete [] ((::TGeoArb8*)p);
   }
   static void destruct_TGeoArb8(void *p) {
      typedef ::TGeoArb8 current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoArb8(TBuffer &buf, void *obj) {
      ((::TGeoArb8*)obj)->::TGeoArb8::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoArb8

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

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

//______________________________________________________________________________
void TGeoTrap::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoTrap.
      TClass *R__cl = ::TGeoTrap::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta", &fTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi", &fPhi);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fH1", &fH1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBl1", &fBl1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTl1", &fTl1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlpha1", &fAlpha1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fH2", &fH2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBl2", &fBl2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTl2", &fTl2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlpha2", &fAlpha2);
      TGeoArb8::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoTrap(void *p) {
      return  p ? new(p) ::TGeoTrap : new ::TGeoTrap;
   }
   static void *newArray_TGeoTrap(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoTrap[nElements] : new ::TGeoTrap[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoTrap(void *p) {
      delete ((::TGeoTrap*)p);
   }
   static void deleteArray_TGeoTrap(void *p) {
      delete [] ((::TGeoTrap*)p);
   }
   static void destruct_TGeoTrap(void *p) {
      typedef ::TGeoTrap current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoTrap

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoGtra(void *p) {
      return  p ? new(p) ::TGeoGtra : new ::TGeoGtra;
   }
   static void *newArray_TGeoGtra(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoGtra[nElements] : new ::TGeoGtra[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoGtra(void *p) {
      delete ((::TGeoGtra*)p);
   }
   static void deleteArray_TGeoGtra(void *p) {
      delete [] ((::TGeoGtra*)p);
   }
   static void destruct_TGeoGtra(void *p) {
      typedef ::TGeoGtra current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoGtra

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoTrd1(void *p) {
      return  p ? new(p) ::TGeoTrd1 : new ::TGeoTrd1;
   }
   static void *newArray_TGeoTrd1(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoTrd1[nElements] : new ::TGeoTrd1[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoTrd1(void *p) {
      delete ((::TGeoTrd1*)p);
   }
   static void deleteArray_TGeoTrd1(void *p) {
      delete [] ((::TGeoTrd1*)p);
   }
   static void destruct_TGeoTrd1(void *p) {
      typedef ::TGeoTrd1 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoTrd1

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

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

//______________________________________________________________________________
void TGeoTrd2::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoTrd2.
      TClass *R__cl = ::TGeoTrd2::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDx1", &fDx1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDx2", &fDx2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDy1", &fDy1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDy2", &fDy2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDz", &fDz);
      TGeoBBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoTrd2(void *p) {
      return  p ? new(p) ::TGeoTrd2 : new ::TGeoTrd2;
   }
   static void *newArray_TGeoTrd2(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoTrd2[nElements] : new ::TGeoTrd2[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoTrd2(void *p) {
      delete ((::TGeoTrd2*)p);
   }
   static void deleteArray_TGeoTrd2(void *p) {
      delete [] ((::TGeoTrd2*)p);
   }
   static void destruct_TGeoTrd2(void *p) {
      typedef ::TGeoTrd2 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoTrd2

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoCompositeShape(void *p) {
      return  p ? new(p) ::TGeoCompositeShape : new ::TGeoCompositeShape;
   }
   static void *newArray_TGeoCompositeShape(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoCompositeShape[nElements] : new ::TGeoCompositeShape[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoCompositeShape(void *p) {
      delete ((::TGeoCompositeShape*)p);
   }
   static void deleteArray_TGeoCompositeShape(void *p) {
      delete [] ((::TGeoCompositeShape*)p);
   }
   static void destruct_TGeoCompositeShape(void *p) {
      typedef ::TGeoCompositeShape current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoCompositeShape

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoPolygon(void *p) {
      return  p ? new(p) ::TGeoPolygon : new ::TGeoPolygon;
   }
   static void *newArray_TGeoPolygon(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoPolygon[nElements] : new ::TGeoPolygon[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoPolygon(void *p) {
      delete ((::TGeoPolygon*)p);
   }
   static void deleteArray_TGeoPolygon(void *p) {
      delete [] ((::TGeoPolygon*)p);
   }
   static void destruct_TGeoPolygon(void *p) {
      typedef ::TGeoPolygon current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoPolygon

//______________________________________________________________________________
void TGeoXtru::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoXtru.
      TClass *R__cl = ::TGeoXtru::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNvert", &fNvert);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNz", &fNz);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fZcurrent", &fZcurrent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPoly", &fPoly);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fX", &fX);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fY", &fY);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXc", &fXc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYc", &fYc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZ", &fZ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScale", &fScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fX0", &fX0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fY0", &fY0);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeg", &fSeg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIz", &fIz);
      TGeoBBox::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoXtru(void *p) {
      return  p ? new(p) ::TGeoXtru : new ::TGeoXtru;
   }
   static void *newArray_TGeoXtru(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoXtru[nElements] : new ::TGeoXtru[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoXtru(void *p) {
      delete ((::TGeoXtru*)p);
   }
   static void deleteArray_TGeoXtru(void *p) {
      delete [] ((::TGeoXtru*)p);
   }
   static void destruct_TGeoXtru(void *p) {
      typedef ::TGeoXtru current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoXtru(TBuffer &buf, void *obj) {
      ((::TGeoXtru*)obj)->::TGeoXtru::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoXtru

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoShapeAssembly(void *p) {
      return  p ? new(p) ::TGeoShapeAssembly : new ::TGeoShapeAssembly;
   }
   static void *newArray_TGeoShapeAssembly(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoShapeAssembly[nElements] : new ::TGeoShapeAssembly[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoShapeAssembly(void *p) {
      delete ((::TGeoShapeAssembly*)p);
   }
   static void deleteArray_TGeoShapeAssembly(void *p) {
      delete [] ((::TGeoShapeAssembly*)p);
   }
   static void destruct_TGeoShapeAssembly(void *p) {
      typedef ::TGeoShapeAssembly current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoShapeAssembly

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoScaledShape(void *p) {
      return  p ? new(p) ::TGeoScaledShape : new ::TGeoScaledShape;
   }
   static void *newArray_TGeoScaledShape(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoScaledShape[nElements] : new ::TGeoScaledShape[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoScaledShape(void *p) {
      delete ((::TGeoScaledShape*)p);
   }
   static void deleteArray_TGeoScaledShape(void *p) {
      delete [] ((::TGeoScaledShape*)p);
   }
   static void destruct_TGeoScaledShape(void *p) {
      typedef ::TGeoScaledShape current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoScaledShape

//______________________________________________________________________________
void TGeoVolume::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoVolume.
      TClass *R__cl = ::TGeoVolume::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodes", &fNodes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedium", &fMedium);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFinder", &fFinder);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVoxels", &fVoxels);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGeoManager", &fGeoManager);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fField", &fField);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOption", &fOption);
      R__insp.InspectMember(fOption, "fOption.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumber", &fNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNtotal", &fNtotal);
      TNamed::ShowMembers(R__insp);
      TGeoAtt::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
      TAttFill::ShowMembers(R__insp);
      TAtt3D::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoVolume(void *p) {
      return  p ? new(p) ::TGeoVolume : new ::TGeoVolume;
   }
   static void *newArray_TGeoVolume(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoVolume[nElements] : new ::TGeoVolume[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoVolume(void *p) {
      delete ((::TGeoVolume*)p);
   }
   static void deleteArray_TGeoVolume(void *p) {
      delete [] ((::TGeoVolume*)p);
   }
   static void destruct_TGeoVolume(void *p) {
      typedef ::TGeoVolume current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoVolume(TBuffer &buf, void *obj) {
      ((::TGeoVolume*)obj)->::TGeoVolume::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoVolume

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoVolumeAssembly(void *p) {
      return  p ? new(p) ::TGeoVolumeAssembly : new ::TGeoVolumeAssembly;
   }
   static void *newArray_TGeoVolumeAssembly(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoVolumeAssembly[nElements] : new ::TGeoVolumeAssembly[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoVolumeAssembly(void *p) {
      delete ((::TGeoVolumeAssembly*)p);
   }
   static void deleteArray_TGeoVolumeAssembly(void *p) {
      delete [] ((::TGeoVolumeAssembly*)p);
   }
   static void destruct_TGeoVolumeAssembly(void *p) {
      typedef ::TGeoVolumeAssembly current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoVolumeAssembly

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

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

//______________________________________________________________________________
void TGeoVolumeMulti::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoVolumeMulti.
      TClass *R__cl = ::TGeoVolumeMulti::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolumes", &fVolumes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDivision", &fDivision);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumed", &fNumed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdiv", &fNdiv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAxis", &fAxis);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStart", &fStart);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStep", &fStep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAttSet", &fAttSet);
      TGeoVolume::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoVolumeMulti(void *p) {
      return  p ? new(p) ::TGeoVolumeMulti : new ::TGeoVolumeMulti;
   }
   static void *newArray_TGeoVolumeMulti(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoVolumeMulti[nElements] : new ::TGeoVolumeMulti[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoVolumeMulti(void *p) {
      delete ((::TGeoVolumeMulti*)p);
   }
   static void deleteArray_TGeoVolumeMulti(void *p) {
      delete [] ((::TGeoVolumeMulti*)p);
   }
   static void destruct_TGeoVolumeMulti(void *p) {
      typedef ::TGeoVolumeMulti current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoVolumeMulti

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

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

//______________________________________________________________________________
void TGeoNode::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoNode.
      TClass *R__cl = ::TGeoNode::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolume", &fVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMother", &fMother);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumber", &fNumber);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNovlp", &fNovlp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOverlaps", &fOverlaps);
      TNamed::ShowMembers(R__insp);
      TGeoAtt::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TGeoNode(void *p) {
      delete ((::TGeoNode*)p);
   }
   static void deleteArray_TGeoNode(void *p) {
      delete [] ((::TGeoNode*)p);
   }
   static void destruct_TGeoNode(void *p) {
      typedef ::TGeoNode current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoNode

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

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

//______________________________________________________________________________
void TGeoPhysicalNode::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoPhysicalNode.
      TClass *R__cl = ::TGeoPhysicalNode::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLevel", &fLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrices", &fMatrices);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodes", &fNodes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrixOrig", &fMatrixOrig);
      TNamed::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoPhysicalNode(void *p) {
      return  p ? new(p) ::TGeoPhysicalNode : new ::TGeoPhysicalNode;
   }
   static void *newArray_TGeoPhysicalNode(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoPhysicalNode[nElements] : new ::TGeoPhysicalNode[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoPhysicalNode(void *p) {
      delete ((::TGeoPhysicalNode*)p);
   }
   static void deleteArray_TGeoPhysicalNode(void *p) {
      delete [] ((::TGeoPhysicalNode*)p);
   }
   static void destruct_TGeoPhysicalNode(void *p) {
      typedef ::TGeoPhysicalNode current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoPhysicalNode

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoPNEntry(void *p) {
      return  p ? new(p) ::TGeoPNEntry : new ::TGeoPNEntry;
   }
   static void *newArray_TGeoPNEntry(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoPNEntry[nElements] : new ::TGeoPNEntry[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoPNEntry(void *p) {
      delete ((::TGeoPNEntry*)p);
   }
   static void deleteArray_TGeoPNEntry(void *p) {
      delete [] ((::TGeoPNEntry*)p);
   }
   static void destruct_TGeoPNEntry(void *p) {
      typedef ::TGeoPNEntry current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoPNEntry

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoNodeMatrix(void *p) {
      return  p ? new(p) ::TGeoNodeMatrix : new ::TGeoNodeMatrix;
   }
   static void *newArray_TGeoNodeMatrix(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoNodeMatrix[nElements] : new ::TGeoNodeMatrix[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoNodeMatrix(void *p) {
      delete ((::TGeoNodeMatrix*)p);
   }
   static void deleteArray_TGeoNodeMatrix(void *p) {
      delete [] ((::TGeoNodeMatrix*)p);
   }
   static void destruct_TGeoNodeMatrix(void *p) {
      typedef ::TGeoNodeMatrix current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoNodeMatrix

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

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

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoNodeOffset(void *p) {
      return  p ? new(p) ::TGeoNodeOffset : new ::TGeoNodeOffset;
   }
   static void *newArray_TGeoNodeOffset(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoNodeOffset[nElements] : new ::TGeoNodeOffset[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoNodeOffset(void *p) {
      delete ((::TGeoNodeOffset*)p);
   }
   static void deleteArray_TGeoNodeOffset(void *p) {
      delete [] ((::TGeoNodeOffset*)p);
   }
   static void destruct_TGeoNodeOffset(void *p) {
      typedef ::TGeoNodeOffset current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoNodeOffset

//______________________________________________________________________________
void TGeoManager::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoManager.
      TClass *R__cl = ::TGeoManager::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhimin", &fPhimin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhimax", &fPhimax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTmin", &fTmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTmax", &fTmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNNodes", &fNNodes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPath", &fPath);
      R__insp.InspectMember(fPath, "fPath.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParticleName", &fParticleName);
      R__insp.InspectMember(fParticleName, "fParticleName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVisDensity", &fVisDensity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fExplodedView", &fExplodedView);
      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(), "fNsegments", &fNsegments);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNtracks", &fNtracks);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxVisNodes", &fMaxVisNodes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentTrack", &fCurrentTrack);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpdg", &fNpdg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPdgId[256]", fPdgId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClosed", &fClosed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLoopVolumes", &fLoopVolumes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStreamVoxels", &fStreamVoxels);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsGeomReading", &fIsGeomReading);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhiCut", &fPhiCut);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeCut", &fTimeCut);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawExtra", &fDrawExtra);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMatrixTransform", &fMatrixTransform);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMatrixReflection", &fMatrixReflection);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActivity", &fActivity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsNodeSelectable", &fIsNodeSelectable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPainter", &fPainter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrices", &fMatrices);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapes", &fShapes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolumes", &fVolumes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPhysicalNodes", &fPhysicalNodes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGShapes", &fGShapes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGVolumes", &fGVolumes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTracks", &fTracks);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPdgNames", &fPdgNames);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNavigators", &fNavigators);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaterials", &fMaterials);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedia", &fMedia);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodes", &fNodes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOverlaps", &fOverlaps);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBits", &fBits);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentNavigator", &fCurrentNavigator);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentVolume", &fCurrentVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTopVolume", &fTopVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTopNode", &fTopNode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMasterVolume", &fMasterVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGLMatrix", &fGLMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUniqueVolumes", &fUniqueVolumes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClippingShape", &fClippingShape);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElementTable", &fElementTable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodeIdArray", &fNodeIdArray);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIntSize", &fIntSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDblSize", &fDblSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIntBuffer", &fIntBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNLevel", &fNLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDblBuffer", &fDblBuffer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPaintVolume", &fPaintVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHashVolumes", &fHashVolumes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHashGVolumes", &fHashGVolumes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHashPNE", &fHashPNE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fArrayPNE", &fArrayPNE);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSizePNEId", &fSizePNEId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNPNEId", &fNPNEId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fKeyPNEId", &fKeyPNEId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValuePNEId", &fValuePNEId);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoManager(void *p) {
      return  p ? new(p) ::TGeoManager : new ::TGeoManager;
   }
   static void *newArray_TGeoManager(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoManager[nElements] : new ::TGeoManager[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoManager(void *p) {
      delete ((::TGeoManager*)p);
   }
   static void deleteArray_TGeoManager(void *p) {
      delete [] ((::TGeoManager*)p);
   }
   static void destruct_TGeoManager(void *p) {
      typedef ::TGeoManager current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TGeoManager(TBuffer &buf, void *obj) {
      ((::TGeoManager*)obj)->::TGeoManager::Streamer(buf);
   }
} // end of namespace ROOT for class ::TGeoManager

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TVirtualGeoPainter(void *p) {
      delete ((::TVirtualGeoPainter*)p);
   }
   static void deleteArray_TVirtualGeoPainter(void *p) {
      delete [] ((::TVirtualGeoPainter*)p);
   }
   static void destruct_TVirtualGeoPainter(void *p) {
      typedef ::TVirtualGeoPainter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TVirtualGeoPainter

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

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

//______________________________________________________________________________
void TVirtualGeoTrack::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TVirtualGeoTrack.
      TClass *R__cl = ::TVirtualGeoTrack::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPDG", &fPDG);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fId", &fId);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParent", &fParent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParticle", &fParticle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTracks", &fTracks);
      TObject::ShowMembers(R__insp);
      TGeoAtt::ShowMembers(R__insp);
      TAttLine::ShowMembers(R__insp);
      TAttMarker::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TVirtualGeoTrack(void *p) {
      delete ((::TVirtualGeoTrack*)p);
   }
   static void deleteArray_TVirtualGeoTrack(void *p) {
      delete [] ((::TVirtualGeoTrack*)p);
   }
   static void destruct_TVirtualGeoTrack(void *p) {
      typedef ::TVirtualGeoTrack current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TVirtualGeoTrack

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

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

//______________________________________________________________________________
void TGeoIterator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoIterator.
      TClass *R__cl = ::TGeoIterator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTop", &fTop);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMustResume", &fMustResume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMustStop", &fMustStop);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLevel", &fLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fArray", &fArray);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &fMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTopName", &fTopName);
      R__insp.InspectMember(fTopName, "fTopName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPlugin", &fPlugin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPluginAutoexec", &fPluginAutoexec);
}

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

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

   TObject::Streamer(R__b);
}

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

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

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

   TObject::Streamer(R__b);
}

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

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

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

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

//______________________________________________________________________________
void TGeoNavigator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TGeoNavigator.
      TClass *R__cl = ::TGeoNavigator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStep", &fStep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSafety", &fSafety);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastSafety", &fLastSafety);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormal[3]", fNormal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCldir[3]", fCldir);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCldirChecked[3]", fCldirChecked);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPoint[3]", fPoint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirection[3]", fDirection);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastPoint[3]", fLastPoint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLevel", &fLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNmany", &fNmany);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNextDaughterIndex", &fNextDaughterIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOverlapSize", &fOverlapSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOverlapMark", &fOverlapMark);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOverlapClusters", &fOverlapClusters);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSearchOverlaps", &fSearchOverlaps);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentOverlapping", &fCurrentOverlapping);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStartSafe", &fStartSafe);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsEntering", &fIsEntering);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsExiting", &fIsExiting);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsStepEntering", &fIsStepEntering);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsStepExiting", &fIsStepExiting);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsOutside", &fIsOutside);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsOnBoundary", &fIsOnBoundary);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsSameLocation", &fIsSameLocation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsNullStep", &fIsNullStep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGeometry", &fGeometry);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCache", &fCache);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentVolume", &fCurrentVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentNode", &fCurrentNode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTopNode", &fTopNode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLastNode", &fLastNode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNextNode", &fNextNode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fForcedNode", &fForcedNode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBackupState", &fBackupState);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentMatrix", &fCurrentMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGlobalMatrix", &fGlobalMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPath", &fPath);
      R__insp.InspectMember(fPath, "fPath.");
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TGeoNavigator(void *p) {
      return  p ? new(p) ::TGeoNavigator : new ::TGeoNavigator;
   }
   static void *newArray_TGeoNavigator(Long_t nElements, void *p) {
      return p ? new(p) ::TGeoNavigator[nElements] : new ::TGeoNavigator[nElements];
   }
   // Wrapper around operator delete
   static void delete_TGeoNavigator(void *p) {
      delete ((::TGeoNavigator*)p);
   }
   static void deleteArray_TGeoNavigator(void *p) {
      delete [] ((::TGeoNavigator*)p);
   }
   static void destruct_TGeoNavigator(void *p) {
      typedef ::TGeoNavigator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TGeoNavigator

/********************************************************
* geom/geom/src/G__Geom1.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__Geom1();

extern "C" void G__set_cpp_environmentG__Geom1() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TGeoAtt.h");
  G__add_compiledheader("TGeoBoolNode.h");
  G__add_compiledheader("TGeoMedium.h");
  G__add_compiledheader("TGeoMaterial.h");
  G__add_compiledheader("TGeoMatrix.h");
  G__add_compiledheader("TGeoVolume.h");
  G__add_compiledheader("TGeoNode.h");
  G__add_compiledheader("TGeoVoxelFinder.h");
  G__add_compiledheader("TGeoShape.h");
  G__add_compiledheader("TGeoBBox.h");
  G__add_compiledheader("TGeoPara.h");
  G__add_compiledheader("TGeoTube.h");
  G__add_compiledheader("TGeoTorus.h");
  G__add_compiledheader("TGeoSphere.h");
  G__add_compiledheader("TGeoEltu.h");
  G__add_compiledheader("TGeoHype.h");
  G__add_compiledheader("TGeoCone.h");
  G__add_compiledheader("TGeoPcon.h");
  G__add_compiledheader("TGeoPgon.h");
  G__add_compiledheader("TGeoArb8.h");
  G__add_compiledheader("TGeoTrd1.h");
  G__add_compiledheader("TGeoTrd2.h");
  G__add_compiledheader("TGeoManager.h");
  G__add_compiledheader("TGeoCompositeShape.h");
  G__add_compiledheader("TGeoShapeAssembly.h");
  G__add_compiledheader("TGeoScaledShape.h");
  G__add_compiledheader("TVirtualGeoPainter.h");
  G__add_compiledheader("TVirtualGeoTrack.h");
  G__add_compiledheader("TGeoPolygon.h");
  G__add_compiledheader("TGeoXtru.h");
  G__add_compiledheader("TGeoPhysicalNode.h");
  G__add_compiledheader("TGeoHelix.h");
  G__add_compiledheader("TGeoParaboloid.h");
  G__add_compiledheader("TGeoElement.h");
  G__add_compiledheader("TGeoHalfSpace.h");
  G__add_compiledheader("TGeoBuilder.h");
  G__add_compiledheader("TGeoNavigator.h");
  G__cpp_reset_tagtableG__Geom1();
}
#include <new>
extern "C" int G__cpp_dllrevG__Geom1() { return(30051515); }

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

/* TGeoAtt */
static int G__G__Geom1_99_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoAtt* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoAtt[n];
     } else {
       p = new((void*) gvp) TGeoAtt[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoAtt;
     } else {
       p = new((void*) gvp) TGeoAtt;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoAtt* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoAtt(
(Option_t*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGeoAtt(
(Option_t*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoAtt((Option_t*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoAtt((Option_t*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoAtt((Option_t*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGeoAtt((Option_t*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoAtt*) G__getstructoffset())->SetAttBit((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoAtt*) G__getstructoffset())->SetAttBit((UInt_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__Geom1_99_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoAtt*) G__getstructoffset())->ResetAttBit((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoAtt*) G__getstructoffset())->TestAttBit((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoAtt*) G__getstructoffset())->SetVisRaytrace((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoAtt*) G__getstructoffset())->SetVisRaytrace();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoAtt*) G__getstructoffset())->SetVisBranch();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoAtt*) G__getstructoffset())->SetVisContainers((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoAtt*) G__getstructoffset())->SetVisContainers();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoAtt*) G__getstructoffset())->SetVisLeaves((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoAtt*) G__getstructoffset())->SetVisLeaves();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoAtt*) G__getstructoffset())->SetVisOnly((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoAtt*) G__getstructoffset())->SetVisOnly();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoAtt*) G__getstructoffset())->SetVisibility((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoAtt*) G__getstructoffset())->SetVisibility();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoAtt*) G__getstructoffset())->SetVisDaughters((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoAtt*) G__getstructoffset())->SetVisDaughters();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoAtt*) G__getstructoffset())->SetVisStreamed((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoAtt*) G__getstructoffset())->SetVisStreamed();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoAtt*) G__getstructoffset())->SetVisTouched((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoAtt*) G__getstructoffset())->SetVisTouched();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoAtt*) G__getstructoffset())->SetActivity((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoAtt*) G__getstructoffset())->SetActivity();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoAtt*) G__getstructoffset())->SetActiveDaughters((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoAtt*) G__getstructoffset())->SetActiveDaughters();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoAtt*) G__getstructoffset())->SetOptimization((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoAtt*) G__getstructoffset())->IsActive());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoAtt*) G__getstructoffset())->IsActiveDaughters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoAtt*) G__getstructoffset())->IsVisRaytrace());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoAtt*) G__getstructoffset())->IsVisible());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoAtt*) G__getstructoffset())->IsVisDaughters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoAtt*) G__getstructoffset())->IsVisBranch());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoAtt*) G__getstructoffset())->IsVisContainers());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoAtt*) G__getstructoffset())->IsVisLeaves());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoAtt*) G__getstructoffset())->IsVisOnly());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoAtt*) G__getstructoffset())->IsVisStreamed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoAtt*) G__getstructoffset())->IsVisTouched());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoAtt::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoAtt::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoAtt::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoAtt::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_99_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoAtt*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoAtt*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoAtt*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoAtt::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoAtt::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoAtt::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_99_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoAtt::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_99_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoAtt* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoAtt(*(TGeoAtt*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoAtt G__TTGeoAtt;
static int G__G__Geom1_99_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoAtt*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoAtt*) (soff+(sizeof(TGeoAtt)*i)))->~G__TTGeoAtt();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoAtt*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoAtt*) (soff))->~G__TTGeoAtt();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_99_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoAtt* dest = (TGeoAtt*) G__getstructoffset();
   *dest = *(TGeoAtt*) libp->para[0].ref;
   const TGeoAtt& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoShape */
static int G__G__Geom1_105_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoShape::Big());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoShape::GetTransform());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoShape::SetTransform((TGeoMatrix*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoShape::Tolerance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoShape::ComputeEpsMch());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoShape::EpsMch());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoShape*) G__getstructoffset())->Capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoShape*) G__getstructoffset())->ComputeBBox();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoShape*) G__getstructoffset())->ComputeNormal((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoShape*) G__getstructoffset())->Contains((Double_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoShape*) G__getstructoffset())->CouldBeCrossed((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((const TGeoShape*) G__getstructoffset())->DistFromInside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t*) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const TGeoShape*) G__getstructoffset())->DistFromInside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const TGeoShape*) G__getstructoffset())->DistFromInside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TGeoShape*) G__getstructoffset())->DistFromInside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((const TGeoShape*) G__getstructoffset())->DistFromOutside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t*) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const TGeoShape*) G__getstructoffset())->DistFromOutside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const TGeoShape*) G__getstructoffset())->DistFromOutside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TGeoShape*) G__getstructoffset())->DistFromOutside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 9:
      G__letdouble(result7, 100, (double) TGeoShape::DistToPhiMin(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Bool_t) G__int(libp->para[8])));
      break;
   case 8:
      G__letdouble(result7, 100, (double) TGeoShape::DistToPhiMin(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoShape*) G__getstructoffset())->Divide((TGeoVolume*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGeoShape*) G__getstructoffset())->GetAxisName((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoShape*) G__getstructoffset())->GetAxisRange((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoShape*) G__getstructoffset())->GetBoundingCylinder((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TBuffer3D& obj = ((const TGeoShape*) G__getstructoffset())->GetBuffer3D((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoShape*) G__getstructoffset())->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoShape*) G__getstructoffset())->GetPointsOnSegments((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoShape*) G__getstructoffset())->GetFittingBox((TGeoBBox*) G__int(libp->para[0]), (TGeoMatrix*) G__int(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoShape*) G__getstructoffset())->GetId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoShape*) G__getstructoffset())->GetMakeRuntimeShape((TGeoShape*) G__int(libp->para[0]), (TGeoMatrix*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoShape*) G__getstructoffset())->GetMeshNumbers(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoShape*) G__getstructoffset())->GetNmeshVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGeoShape*) G__getstructoffset())->GetPointerName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoShape*) G__getstructoffset())->IsAssembly());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoShape*) G__getstructoffset())->IsComposite());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoShape*) G__getstructoffset())->IsCylType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGeoShape::IsCloseToPhi((Double_t) G__double(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGeoShape::IsCrossingSemiplane((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGeoShape::IsSameWithinTolerance((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGeoShape::IsSegCrossing(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGeoShape::IsInPhiRange((Double_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoShape*) G__getstructoffset())->IsReflected());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoShape*) G__getstructoffset())->IsRunTimeShape());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoShape*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoShape*) G__getstructoffset())->IsValidBox());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoShape*) G__getstructoffset())->InspectShape();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_105_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoShape::NormalPhi(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TGeoShape*) G__getstructoffset())->Safety((Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TGeoShape*) G__getstructoffset())->Safety((Double_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoShape::SafetyPhi((Double_t*) G__int(libp->para[0]), (Bool_t) G__int(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__Geom1_105_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoShape*) G__getstructoffset())->SetDimensions((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoShape*) G__getstructoffset())->SetId((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoShape*) G__getstructoffset())->SetPoints((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoShape*) G__getstructoffset())->SetPoints((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoShape*) G__getstructoffset())->SetSegsAndPols(*(TBuffer3D*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoShape*) G__getstructoffset())->SetRuntime((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoShape*) G__getstructoffset())->SetRuntime();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoShape*) G__getstructoffset())->ShapeDistancetoPrimitive((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoShape*) G__getstructoffset())->Sizeof3D();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoShape*) G__getstructoffset())->SetShapeBit((UInt_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__Geom1_105_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoShape*) G__getstructoffset())->SetShapeBit((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoShape*) G__getstructoffset())->ResetShapeBit((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoShape*) G__getstructoffset())->TestShapeBit((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoShape*) G__getstructoffset())->TestShapeBits((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoShape*) G__getstructoffset())->InvertShapeBit((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoShape::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoShape::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoShape::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoShape::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoShape*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoShape::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoShape::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoShape::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_105_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoShape::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoShape G__TTGeoShape;
static int G__G__Geom1_105_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoShape*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoShape*) (soff+(sizeof(TGeoShape)*i)))->~G__TTGeoShape();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoShape*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoShape*) (soff))->~G__TTGeoShape();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_105_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoShape* dest = (TGeoShape*) G__getstructoffset();
   *dest = *(TGeoShape*) libp->para[0].ref;
   const TGeoShape& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoMatrix */
static int G__G__Geom1_106_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoMatrix& obj = ((TGeoMatrix*) G__getstructoffset())->operator=(*(TGeoMatrix*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoMatrix& obj = ((const TGeoMatrix*) G__getstructoffset())->operator*(*(TGeoMatrix*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoMatrix*) G__getstructoffset())->operator==(*(TGeoMatrix*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoMatrix*) G__getstructoffset())->IsIdentity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoMatrix*) G__getstructoffset())->IsTranslation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoMatrix*) G__getstructoffset())->IsRotation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoMatrix*) G__getstructoffset())->IsReflection());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoMatrix*) G__getstructoffset())->IsScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoMatrix*) G__getstructoffset())->IsCombi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoMatrix*) G__getstructoffset())->IsGeneral());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoMatrix*) G__getstructoffset())->IsRegistered());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoMatrix*) G__getstructoffset())->IsRotAboutZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoMatrix*) G__getstructoffset())->GetHomogenousMatrix((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGeoMatrix*) G__getstructoffset())->GetPointerName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoMatrix*) G__getstructoffset())->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoMatrix*) G__getstructoffset())->GetTranslation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoMatrix*) G__getstructoffset())->GetRotationMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoMatrix*) G__getstructoffset())->GetScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoMatrix& obj = ((const TGeoMatrix*) G__getstructoffset())->Inverse();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoMatrix*) G__getstructoffset())->LocalToMaster((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoMatrix*) G__getstructoffset())->LocalToMasterVect((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoMatrix*) G__getstructoffset())->LocalToMasterBomb((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_106_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoMatrix*) G__getstructoffset())->MasterToLocal((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoMatrix*) G__getstructoffset())->MasterToLocalVect((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoMatrix*) G__getstructoffset())->MasterToLocalBomb((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoMatrix::Normalize((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMatrix*) G__getstructoffset())->RotateX((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMatrix*) G__getstructoffset())->RotateY((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMatrix*) G__getstructoffset())->RotateZ((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGeoMatrix*) G__getstructoffset())->ReflectX((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoMatrix*) G__getstructoffset())->ReflectX((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGeoMatrix*) G__getstructoffset())->ReflectY((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoMatrix*) G__getstructoffset())->ReflectY((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGeoMatrix*) G__getstructoffset())->ReflectZ((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoMatrix*) G__getstructoffset())->ReflectZ((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMatrix*) G__getstructoffset())->RegisterYourself();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMatrix*) G__getstructoffset())->SetDefaultName();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMatrix*) G__getstructoffset())->SetDx((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMatrix*) G__getstructoffset())->SetDy((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMatrix*) G__getstructoffset())->SetDz((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoMatrix::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoMatrix::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoMatrix::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoMatrix::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMatrix*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoMatrix::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoMatrix::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoMatrix::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_106_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoMatrix::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoMatrix G__TTGeoMatrix;
static int G__G__Geom1_106_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoMatrix*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoMatrix*) (soff+(sizeof(TGeoMatrix)*i)))->~G__TTGeoMatrix();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoMatrix*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoMatrix*) (soff))->~G__TTGeoMatrix();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoHMatrix */
static int G__G__Geom1_107_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoHMatrix* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoHMatrix[n];
     } else {
       p = new((void*) gvp) TGeoHMatrix[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoHMatrix;
     } else {
       p = new((void*) gvp) TGeoHMatrix;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoHMatrix* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoHMatrix(*(TGeoMatrix*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGeoHMatrix(*(TGeoMatrix*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoHMatrix* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoHMatrix((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoHMatrix((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoHMatrix& obj = ((TGeoHMatrix*) G__getstructoffset())->operator=((TGeoMatrix*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoHMatrix& obj = ((TGeoHMatrix*) G__getstructoffset())->operator=(*(TGeoMatrix*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoHMatrix& obj = ((TGeoHMatrix*) G__getstructoffset())->operator=(*(TGeoHMatrix*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoHMatrix& obj = ((TGeoHMatrix*) G__getstructoffset())->operator*=(*(TGeoMatrix*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHMatrix*) G__getstructoffset())->CopyFrom((TGeoMatrix*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoHMatrix*) G__getstructoffset())->Determinant());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHMatrix*) G__getstructoffset())->Multiply((TGeoMatrix*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHMatrix*) G__getstructoffset())->MultiplyLeft((TGeoMatrix*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHMatrix*) G__getstructoffset())->SetTranslation((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHMatrix*) G__getstructoffset())->SetRotation((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHMatrix*) G__getstructoffset())->SetScale((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGeoHMatrix*) G__getstructoffset())->GetTranslation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGeoHMatrix*) G__getstructoffset())->GetRotationMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGeoHMatrix*) G__getstructoffset())->GetScale());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoHMatrix::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoHMatrix::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoHMatrix::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoHMatrix::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHMatrix*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoHMatrix::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoHMatrix::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoHMatrix::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_107_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoHMatrix::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_107_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoHMatrix* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoHMatrix(*(TGeoHMatrix*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoHMatrix G__TTGeoHMatrix;
static int G__G__Geom1_107_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoHMatrix*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoHMatrix*) (soff+(sizeof(TGeoHMatrix)*i)))->~G__TTGeoHMatrix();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoHMatrix*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoHMatrix*) (soff))->~G__TTGeoHMatrix();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoBoolNode */
static int G__G__Geom1_108_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoBoolNode*) G__getstructoffset())->ComputeBBox(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), (Double_t*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoBoolNode*) G__getstructoffset())->ComputeNormal((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoBoolNode*) G__getstructoffset())->Contains((Double_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoBoolNode*) G__getstructoffset())->DistanceToPrimitive((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((const TGeoBoolNode*) G__getstructoffset())->DistFromInside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t*) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const TGeoBoolNode*) G__getstructoffset())->DistFromInside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const TGeoBoolNode*) G__getstructoffset())->DistFromInside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TGeoBoolNode*) G__getstructoffset())->DistFromInside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((const TGeoBoolNode*) G__getstructoffset())->DistFromOutside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t*) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const TGeoBoolNode*) G__getstructoffset())->DistFromOutside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const TGeoBoolNode*) G__getstructoffset())->DistFromOutside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TGeoBoolNode*) G__getstructoffset())->DistFromOutside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoBoolNode*) G__getstructoffset())->GetBooleanOperator());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoBoolNode*) G__getstructoffset())->GetNpoints());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Geom1_108_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoBoolNode*) G__getstructoffset())->RegisterMatrices();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TGeoBoolNode*) G__getstructoffset())->Safety((Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TGeoBoolNode*) G__getstructoffset())->Safety((Double_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoBoolNode*) G__getstructoffset())->SetPoints((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoBoolNode*) G__getstructoffset())->SetPoints((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoBoolNode*) G__getstructoffset())->SetSelected((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoBoolNode*) G__getstructoffset())->Sizeof3D();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoBoolNode::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoBoolNode::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoBoolNode::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoBoolNode::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoBoolNode*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoBoolNode::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoBoolNode::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoBoolNode::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_108_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoBoolNode::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoBoolNode G__TTGeoBoolNode;
static int G__G__Geom1_108_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoBoolNode*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoBoolNode*) (soff+(sizeof(TGeoBoolNode)*i)))->~G__TTGeoBoolNode();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoBoolNode*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoBoolNode*) (soff))->~G__TTGeoBoolNode();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoUnion */
static int G__G__Geom1_110_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoUnion* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoUnion[n];
     } else {
       p = new((void*) gvp) TGeoUnion[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoUnion;
     } else {
       p = new((void*) gvp) TGeoUnion;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoUnion));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_110_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoUnion* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoUnion((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGeoUnion((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoUnion));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_110_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoUnion* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoUnion(
(TGeoShape*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]), (TGeoMatrix*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGeoUnion(
(TGeoShape*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]), (TGeoMatrix*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoUnion(
(TGeoShape*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGeoUnion(
(TGeoShape*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoUnion((TGeoShape*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoUnion((TGeoShape*) G__int(libp->para[0]), (TGeoShape*) 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__Geom1LN_TGeoUnion));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_110_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoUnion::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_110_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoUnion::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_110_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoUnion::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_110_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoUnion::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_110_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoUnion*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_110_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoUnion::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_110_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoUnion::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_110_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoUnion::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_110_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoUnion::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoUnion G__TTGeoUnion;
static int G__G__Geom1_110_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[] (TGeoUnion*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoUnion*) (soff+(sizeof(TGeoUnion)*i)))->~G__TTGeoUnion();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoUnion*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoUnion*) (soff))->~G__TTGeoUnion();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoIntersection */
static int G__G__Geom1_111_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoIntersection* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoIntersection[n];
     } else {
       p = new((void*) gvp) TGeoIntersection[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoIntersection;
     } else {
       p = new((void*) gvp) TGeoIntersection;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoIntersection));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_111_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoIntersection* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoIntersection((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGeoIntersection((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoIntersection));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_111_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoIntersection* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoIntersection(
(TGeoShape*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]), (TGeoMatrix*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGeoIntersection(
(TGeoShape*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]), (TGeoMatrix*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoIntersection(
(TGeoShape*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGeoIntersection(
(TGeoShape*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoIntersection((TGeoShape*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoIntersection((TGeoShape*) G__int(libp->para[0]), (TGeoShape*) 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__Geom1LN_TGeoIntersection));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_111_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoIntersection::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_111_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoIntersection::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_111_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoIntersection::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_111_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoIntersection::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_111_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoIntersection*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_111_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoIntersection::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_111_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoIntersection::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_111_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoIntersection::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_111_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoIntersection::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoIntersection G__TTGeoIntersection;
static int G__G__Geom1_111_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[] (TGeoIntersection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoIntersection*) (soff+(sizeof(TGeoIntersection)*i)))->~G__TTGeoIntersection();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoIntersection*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoIntersection*) (soff))->~G__TTGeoIntersection();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoSubtraction */
static int G__G__Geom1_112_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoSubtraction* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSubtraction[n];
     } else {
       p = new((void*) gvp) TGeoSubtraction[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSubtraction;
     } else {
       p = new((void*) gvp) TGeoSubtraction;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoSubtraction));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_112_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoSubtraction* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoSubtraction((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGeoSubtraction((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoSubtraction));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_112_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoSubtraction* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSubtraction(
(TGeoShape*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]), (TGeoMatrix*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGeoSubtraction(
(TGeoShape*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]), (TGeoMatrix*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSubtraction(
(TGeoShape*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGeoSubtraction(
(TGeoShape*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSubtraction((TGeoShape*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoSubtraction((TGeoShape*) G__int(libp->para[0]), (TGeoShape*) 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__Geom1LN_TGeoSubtraction));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_112_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoSubtraction::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_112_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoSubtraction::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_112_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoSubtraction::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_112_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoSubtraction::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_112_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoSubtraction*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_112_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoSubtraction::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_112_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoSubtraction::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_112_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoSubtraction::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_112_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoSubtraction::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoSubtraction G__TTGeoSubtraction;
static int G__G__Geom1_112_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[] (TGeoSubtraction*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoSubtraction*) (soff+(sizeof(TGeoSubtraction)*i)))->~G__TTGeoSubtraction();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoSubtraction*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoSubtraction*) (soff))->~G__TTGeoSubtraction();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoElementTable */
static int G__G__Geom1_137_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoElementTable* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoElementTable[n];
     } else {
       p = new((void*) gvp) TGeoElementTable[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoElementTable;
     } else {
       p = new((void*) gvp) TGeoElementTable;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_137_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElementTable*) G__getstructoffset())->AddElement((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElementTable*) G__getstructoffset())->AddElement((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElementTable*) G__getstructoffset())->AddElementRN((TGeoElementRN*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElementTable*) G__getstructoffset())->AddIsotope((TGeoIsotope*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElementTable*) G__getstructoffset())->BuildDefaultElements();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElementTable*) G__getstructoffset())->ImportElementsRN();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoElementTable*) G__getstructoffset())->CheckTable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoElementTable*) G__getstructoffset())->FindElement((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoElementTable*) G__getstructoffset())->FindIsotope((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoElementTable*) G__getstructoffset())->GetElement((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoElementTable*) G__getstructoffset())->GetElementRN((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((const TGeoElementTable*) G__getstructoffset())->GetElementRN((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((const TGeoElementTable*) G__getstructoffset())->GetElementRN((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_137_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoElementTable*) G__getstructoffset())->HasDefaultElements());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoElementTable*) G__getstructoffset())->HasRNElements());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoElementTable*) G__getstructoffset())->GetNelements());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoElementTable*) G__getstructoffset())->GetNelementsRN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoElementTable*) G__getstructoffset())->ExportElementsRN((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoElementTable*) G__getstructoffset())->ExportElementsRN();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoElementTable::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoElementTable::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoElementTable::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoElementTable::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElementTable*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoElementTable::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoElementTable::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoElementTable::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_137_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoElementTable::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoElementTable G__TTGeoElementTable;
static int G__G__Geom1_137_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoElementTable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoElementTable*) (soff+(sizeof(TGeoElementTable)*i)))->~G__TTGeoElementTable();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoElementTable*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoElementTable*) (soff))->~G__TTGeoElementTable();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoIsotope */
static int G__G__Geom1_138_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoIsotope* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoIsotope[n];
     } else {
       p = new((void*) gvp) TGeoIsotope[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoIsotope;
     } else {
       p = new((void*) gvp) TGeoIsotope;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoIsotope));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoIsotope* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoIsotope(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
   } else {
     p = new((void*) gvp) TGeoIsotope(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoIsotope));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoIsotope*) G__getstructoffset())->GetZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoIsotope*) G__getstructoffset())->GetN());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoIsotope*) G__getstructoffset())->GetA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoIsotope::FindIsotope((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoIsotope::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoIsotope::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoIsotope::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoIsotope::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoIsotope*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoIsotope::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoIsotope::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoIsotope::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_138_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoIsotope::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_138_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoIsotope* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoIsotope(*(TGeoIsotope*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoIsotope));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoIsotope G__TTGeoIsotope;
static int G__G__Geom1_138_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[] (TGeoIsotope*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoIsotope*) (soff+(sizeof(TGeoIsotope)*i)))->~G__TTGeoIsotope();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoIsotope*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoIsotope*) (soff))->~G__TTGeoIsotope();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_138_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoIsotope* dest = (TGeoIsotope*) G__getstructoffset();
   *dest = *(TGeoIsotope*) libp->para[0].ref;
   const TGeoIsotope& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoElement */
static int G__G__Geom1_139_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoElement[n];
     } else {
       p = new((void*) gvp) TGeoElement[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoElement;
     } else {
       p = new((void*) gvp) TGeoElement;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoElement(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
   } else {
     p = new((void*) gvp) TGeoElement(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoElement(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGeoElement(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoElement* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoElement(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   } else {
     p = new((void*) gvp) TGeoElement(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoElement*) G__getstructoffset())->ENDFCode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoElement*) G__getstructoffset())->Z());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoElement*) G__getstructoffset())->N());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoElement*) G__getstructoffset())->Neff());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoElement*) G__getstructoffset())->A());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElement*) G__getstructoffset())->AddIsotope((TGeoIsotope*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoElement*) G__getstructoffset())->GetNisotopes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoElement*) G__getstructoffset())->GetIsotope((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoElement*) G__getstructoffset())->GetRelativeAbundance((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoElement*) G__getstructoffset())->HasIsotopes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoElement*) G__getstructoffset())->IsDefined());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoElement*) G__getstructoffset())->IsRadioNuclide());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoElement*) G__getstructoffset())->IsUsed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoElement*) G__getstructoffset())->SetDefined((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoElement*) G__getstructoffset())->SetDefined();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoElement*) G__getstructoffset())->SetUsed((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoElement*) G__getstructoffset())->SetUsed();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoElement::GetElementTable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoElement::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoElement::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoElement::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoElement::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElement*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoElement::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoElement::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoElement::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_139_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoElement::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoElement G__TTGeoElement;
static int G__G__Geom1_139_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[] (TGeoElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoElement*) (soff+(sizeof(TGeoElement)*i)))->~G__TTGeoElement();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoElement*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoElement*) (soff))->~G__TTGeoElement();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoDecayChannel */
static int G__G__Geom1_141_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoDecayChannel* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoDecayChannel[n];
     } else {
       p = new((void*) gvp) TGeoDecayChannel[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoDecayChannel;
     } else {
       p = new((void*) gvp) TGeoDecayChannel;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannel));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoDecayChannel* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoDecayChannel(
(Int_t) 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]));
   } else {
     p = new((void*) gvp) TGeoDecayChannel(
(Int_t) 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]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannel));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoDecayChannel* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoDecayChannel(*(TGeoDecayChannel*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGeoDecayChannel(*(TGeoDecayChannel*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannel));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoDecayChannel& obj = ((TGeoDecayChannel*) G__getstructoffset())->operator=(*(TGeoDecayChannel*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoDecayChannel*) G__getstructoffset())->GetIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TGeoDecayChannel*) G__getstructoffset())->Decay());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoDecayChannel*) G__getstructoffset())->BranchingRatio());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoDecayChannel*) G__getstructoffset())->Qvalue());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoDecayChannel*) G__getstructoffset())->DeltaIso());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_141_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoDecayChannel::DecayName((UInt_t) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoDecayChannel*) G__getstructoffset())->SetParent((TGeoElementRN*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoDecayChannel*) G__getstructoffset())->SetDaughter((TGeoElementRN*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoDecayChannel::ReadDecay((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoDecayChannel*) G__getstructoffset())->DecayShift(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoDecayChannel::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoDecayChannel::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoDecayChannel::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoDecayChannel::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoDecayChannel*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoDecayChannel::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoDecayChannel::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoDecayChannel::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_141_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoDecayChannel::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoDecayChannel G__TTGeoDecayChannel;
static int G__G__Geom1_141_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[] (TGeoDecayChannel*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoDecayChannel*) (soff+(sizeof(TGeoDecayChannel)*i)))->~G__TTGeoDecayChannel();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoDecayChannel*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoDecayChannel*) (soff))->~G__TTGeoDecayChannel();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoBatemanSol */
static int G__G__Geom1_142_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoBatemanSol* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoBatemanSol[n];
     } else {
       p = new((void*) gvp) TGeoBatemanSol[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoBatemanSol;
     } else {
       p = new((void*) gvp) TGeoBatemanSol;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoBatemanSol* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoBatemanSol((TGeoElementRN*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoBatemanSol((TGeoElementRN*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoBatemanSol* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoBatemanSol((TObjArray*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoBatemanSol((TObjArray*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoBatemanSol* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoBatemanSol(*(TGeoBatemanSol*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGeoBatemanSol(*(TGeoBatemanSol*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoBatemanSol& obj = ((TGeoBatemanSol*) G__getstructoffset())->operator=(*(TGeoBatemanSol*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoBatemanSol& obj = ((TGeoBatemanSol*) G__getstructoffset())->operator+=(*(TGeoBatemanSol*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoBatemanSol*) G__getstructoffset())->Concentration((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoBatemanSol*) G__getstructoffset())->GetCoeff((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoBatemanSol*) G__getstructoffset())->GetRange(*(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__Geom1_142_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoBatemanSol*) G__getstructoffset())->GetElement());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_142_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoBatemanSol*) G__getstructoffset())->GetNcoeff());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGeoBatemanSol*) G__getstructoffset())->SetRange((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoBatemanSol*) G__getstructoffset())->SetRange((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoBatemanSol*) G__getstructoffset())->SetRange();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoBatemanSol*) G__getstructoffset())->SetFactor((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoBatemanSol*) G__getstructoffset())->FindSolution((TObjArray*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoBatemanSol*) G__getstructoffset())->Normalize((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoBatemanSol::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoBatemanSol::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoBatemanSol::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoBatemanSol::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoBatemanSol*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoBatemanSol::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoBatemanSol::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoBatemanSol::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_142_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoBatemanSol::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoBatemanSol G__TTGeoBatemanSol;
static int G__G__Geom1_142_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoBatemanSol*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoBatemanSol*) (soff+(sizeof(TGeoBatemanSol)*i)))->~G__TTGeoBatemanSol();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoBatemanSol*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoBatemanSol*) (soff))->~G__TTGeoBatemanSol();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoElementRN */
static int G__G__Geom1_143_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoElementRN* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoElementRN[n];
     } else {
       p = new((void*) gvp) TGeoElementRN[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoElementRN;
     } else {
       p = new((void*) gvp) TGeoElementRN;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoElementRN* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 13
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoElementRN(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (const char*) G__int(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
, (Int_t) G__int(libp->para[12]));
   } else {
     p = new((void*) gvp) TGeoElementRN(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (const char*) G__int(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
, (Int_t) G__int(libp->para[12]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElementRN*) G__getstructoffset())->AddDecay((Int_t) 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__Geom1_143_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElementRN*) G__getstructoffset())->AddDecay((TGeoDecayChannel*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElementRN*) G__getstructoffset())->AddRatio(*(TGeoBatemanSol*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElementRN*) G__getstructoffset())->ResetRatio();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoElementRN::ENDF((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoElementRN*) G__getstructoffset())->MassNo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoElementRN*) G__getstructoffset())->AtomicNo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoElementRN*) G__getstructoffset())->IsoNo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoElementRN*) G__getstructoffset())->Level());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoElementRN*) G__getstructoffset())->MassEx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoElementRN*) G__getstructoffset())->HalfLife());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoElementRN*) G__getstructoffset())->NatAbun());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGeoElementRN*) G__getstructoffset())->PJ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoElementRN*) G__getstructoffset())->TH_F());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoElementRN*) G__getstructoffset())->TG_F());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoElementRN*) G__getstructoffset())->TH_S());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoElementRN*) G__getstructoffset())->TG_S());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoElementRN*) G__getstructoffset())->Status());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoElementRN*) G__getstructoffset())->Stable());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_143_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoElementRN*) G__getstructoffset())->GetNdecays());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_143_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoElementRN*) G__getstructoffset())->CheckDecays());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoElementRN*) G__getstructoffset())->DecayResult((TGeoDecayChannel*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGeoElementRN*) G__getstructoffset())->FillPopulation((TObjArray*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGeoElementRN*) G__getstructoffset())->FillPopulation((TObjArray*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoElementRN*) G__getstructoffset())->FillPopulation((TObjArray*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoElementRN::ReadElementRN((const char*) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoElementRN::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoElementRN::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoElementRN::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoElementRN::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElementRN*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoElementRN::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoElementRN::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoElementRN::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_143_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoElementRN::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoElementRN G__TTGeoElementRN;
static int G__G__Geom1_143_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoElementRN*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoElementRN*) (soff+(sizeof(TGeoElementRN)*i)))->~G__TTGeoElementRN();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoElementRN*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoElementRN*) (soff))->~G__TTGeoElementRN();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoElemIter */
static int G__G__Geom1_146_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoElemIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoElemIter((TGeoElementRN*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoElemIter((TGeoElementRN*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoElemIter((TGeoElementRN*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGeoElemIter((TGeoElementRN*) 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__Geom1LN_TGeoElemIter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_146_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoElemIter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoElemIter(*(TGeoElemIter*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGeoElemIter(*(TGeoElemIter*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElemIter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_146_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoElemIter& obj = ((TGeoElemIter*) G__getstructoffset())->operator=(*(TGeoElemIter*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_146_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoElemIter*) G__getstructoffset())->operator()());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_146_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoElemIter*) G__getstructoffset())->Next());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Geom1_146_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoElemIter*) G__getstructoffset())->GetLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_146_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoElemIter*) G__getstructoffset())->GetRatio());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_146_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((const TGeoElemIter*) G__getstructoffset())->Print((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const TGeoElemIter*) G__getstructoffset())->Print();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_146_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElemIter*) G__getstructoffset())->SetLimitRatio((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_146_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoElemIter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_146_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoElemIter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_146_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoElemIter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_146_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoElemIter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_146_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElemIter*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_146_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElemIter*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_146_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoElemIter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_146_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoElemIter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_146_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoElemIter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_146_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoElemIter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_146_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoElemIter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoElemIter G__TTGeoElemIter;
static int G__G__Geom1_146_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[] (TGeoElemIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoElemIter*) (soff+(sizeof(TGeoElemIter)*i)))->~G__TTGeoElemIter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoElemIter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoElemIter*) (soff))->~G__TTGeoElemIter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoMaterial */
static int G__G__Geom1_157_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoMaterial* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoMaterial[n];
     } else {
       p = new((void*) gvp) TGeoMaterial[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoMaterial;
     } else {
       p = new((void*) gvp) TGeoMaterial;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoMaterial* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoMaterial((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoMaterial((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoMaterial* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoMaterial(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TGeoMaterial(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoMaterial(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TGeoMaterial(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoMaterial(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TGeoMaterial(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoMaterial* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoMaterial(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (TGeoMaterial::EGeoMaterialState) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     } else {
       p = new((void*) gvp) TGeoMaterial(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (TGeoMaterial::EGeoMaterialState) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoMaterial(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (TGeoMaterial::EGeoMaterialState) G__int(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TGeoMaterial(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (TGeoMaterial::EGeoMaterialState) G__int(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoMaterial(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (TGeoMaterial::EGeoMaterialState) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGeoMaterial(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (TGeoMaterial::EGeoMaterialState) G__int(libp->para[4]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoMaterial* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoMaterial(
(const char*) G__int(libp->para[0]), (TGeoElement*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) TGeoMaterial(
(const char*) G__int(libp->para[0]), (TGeoElement*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoMaterial::Coulomb((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TGeoMaterial*) G__getstructoffset())->DecayMaterial((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGeoMaterial*) G__getstructoffset())->DecayMaterial((Double_t) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGeoMaterial*) G__getstructoffset())->FillMaterialEvolution((TObjArray*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoMaterial*) G__getstructoffset())->FillMaterialEvolution((TObjArray*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoMaterial*) G__getstructoffset())->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoMaterial*) G__getstructoffset())->GetA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoMaterial*) G__getstructoffset())->GetZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoMaterial*) G__getstructoffset())->GetDefaultColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoMaterial*) G__getstructoffset())->GetDensity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TGeoMaterial*) G__getstructoffset())->GetElement((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TGeoMaterial*) G__getstructoffset())->GetElement());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_157_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGeoMaterial*) G__getstructoffset())->GetPointerName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoMaterial*) G__getstructoffset())->GetRadLen());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoMaterial*) G__getstructoffset())->GetIntLen());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoMaterial*) G__getstructoffset())->GetIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_157_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((const TGeoMaterial*) G__getstructoffset())->GetTransparency());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoMaterial*) G__getstructoffset())->GetTemperature());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoMaterial*) G__getstructoffset())->GetPressure());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoMaterial*) G__getstructoffset())->GetState());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoMaterial*) G__getstructoffset())->IsEq((TGeoMaterial*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoMaterial*) G__getstructoffset())->IsUsed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoMaterial*) G__getstructoffset())->IsMixture());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMaterial*) G__getstructoffset())->SetA((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMaterial*) G__getstructoffset())->SetZ((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMaterial*) G__getstructoffset())->SetDensity((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMaterial*) G__getstructoffset())->SetIndex((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMaterial*) G__getstructoffset())->SetCerenkovProperties((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGeoMaterial*) G__getstructoffset())->SetRadLen((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoMaterial*) G__getstructoffset())->SetRadLen((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoMaterial*) G__getstructoffset())->SetUsed((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoMaterial*) G__getstructoffset())->SetUsed();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoMaterial*) G__getstructoffset())->SetTransparency((Char_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoMaterial*) G__getstructoffset())->SetTransparency();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMaterial*) G__getstructoffset())->SetTemperature((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMaterial*) G__getstructoffset())->SetPressure((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMaterial*) G__getstructoffset())->SetState((TGeoMaterial::EGeoMaterialState) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoMaterial::ScreenFactor((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoMaterial::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoMaterial::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoMaterial::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoMaterial::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMaterial*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoMaterial::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoMaterial::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoMaterial::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_157_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoMaterial::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoMaterial G__TTGeoMaterial;
static int G__G__Geom1_157_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoMaterial*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoMaterial*) (soff+(sizeof(TGeoMaterial)*i)))->~G__TTGeoMaterial();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoMaterial*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoMaterial*) (soff))->~G__TTGeoMaterial();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoMixture */
static int G__G__Geom1_160_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoMixture* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoMixture[n];
     } else {
       p = new((void*) gvp) TGeoMixture[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoMixture;
     } else {
       p = new((void*) gvp) TGeoMixture;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoMixture* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoMixture(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TGeoMixture(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoMixture((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoMixture((const char*) 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__Geom1LN_TGeoMixture));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMixture*) G__getstructoffset())->AddElement((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMixture*) G__getstructoffset())->AddElement((TGeoMaterial*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMixture*) G__getstructoffset())->AddElement((TGeoElement*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMixture*) G__getstructoffset())->AddElement((TGeoElement*) 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__Geom1_160_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMixture*) G__getstructoffset())->DefineElement((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMixture*) G__getstructoffset())->DefineElement((Int_t) G__int(libp->para[0]), (TGeoElement*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMixture*) G__getstructoffset())->DefineElement((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoMixture*) G__getstructoffset())->GetNelements());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoMixture*) G__getstructoffset())->GetZmixt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoMixture*) G__getstructoffset())->GetAmixt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoMixture*) G__getstructoffset())->GetWmixt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TGeoMixture*) G__getstructoffset())->GetNmixt());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMixture*) G__getstructoffset())->SetA((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMixture*) G__getstructoffset())->SetZ((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoMixture::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoMixture::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoMixture::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoMixture::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMixture*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoMixture::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoMixture::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoMixture::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_160_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoMixture::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoMixture G__TTGeoMixture;
static int G__G__Geom1_160_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoMixture*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoMixture*) (soff+(sizeof(TGeoMixture)*i)))->~G__TTGeoMixture();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoMixture*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoMixture*) (soff))->~G__TTGeoMixture();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoMedium */
static int G__G__Geom1_161_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoMedium* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoMedium[n];
     } else {
       p = new((void*) gvp) TGeoMedium[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoMedium;
     } else {
       p = new((void*) gvp) TGeoMedium;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoMedium* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoMedium(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TGeoMaterial*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGeoMedium(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TGeoMaterial*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoMedium(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TGeoMaterial*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGeoMedium(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TGeoMaterial*) 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__Geom1LN_TGeoMedium));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoMedium* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 11
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoMedium(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   } else {
     p = new((void*) gvp) TGeoMedium(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoMedium*) G__getstructoffset())->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoMedium*) G__getstructoffset())->GetId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoMedium*) G__getstructoffset())->GetParam((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMedium*) G__getstructoffset())->SetParam((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGeoMedium*) G__getstructoffset())->GetPointerName());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_161_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMedium*) G__getstructoffset())->SetId((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMedium*) G__getstructoffset())->SetMaterial((TGeoMaterial*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMedium*) G__getstructoffset())->SetCerenkovProperties((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoMedium::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoMedium::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoMedium::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoMedium::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoMedium*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoMedium::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoMedium::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoMedium::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_161_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoMedium::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoMedium G__TTGeoMedium;
static int G__G__Geom1_161_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[] (TGeoMedium*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoMedium*) (soff+(sizeof(TGeoMedium)*i)))->~G__TTGeoMedium();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoMedium*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoMedium*) (soff))->~G__TTGeoMedium();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoTranslation */
static int G__G__Geom1_164_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTranslation* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTranslation[n];
     } else {
       p = new((void*) gvp) TGeoTranslation[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTranslation;
     } else {
       p = new((void*) gvp) TGeoTranslation;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTranslation* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTranslation(*(TGeoTranslation*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGeoTranslation(*(TGeoTranslation*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTranslation* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTranslation(*(TGeoMatrix*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGeoTranslation(*(TGeoMatrix*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTranslation* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTranslation(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) TGeoTranslation(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTranslation* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTranslation(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
   } else {
     p = new((void*) gvp) TGeoTranslation(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoTranslation& obj = ((TGeoTranslation*) G__getstructoffset())->operator=(*(TGeoMatrix*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoTranslation& obj = ((TGeoTranslation*) G__getstructoffset())->operator=(*(TGeoTranslation*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTranslation*) G__getstructoffset())->Add((TGeoTranslation*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTranslation*) G__getstructoffset())->Subtract((TGeoTranslation*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTranslation*) G__getstructoffset())->SetTranslation((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTranslation*) G__getstructoffset())->SetTranslation(*(TGeoMatrix*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoTranslation::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTranslation::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoTranslation::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoTranslation::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTranslation*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTranslation::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTranslation::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTranslation::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_164_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTranslation::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoTranslation G__TTGeoTranslation;
static int G__G__Geom1_164_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[] (TGeoTranslation*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoTranslation*) (soff+(sizeof(TGeoTranslation)*i)))->~G__TTGeoTranslation();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoTranslation*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoTranslation*) (soff))->~G__TTGeoTranslation();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoRotation */
static int G__G__Geom1_165_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoRotation* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoRotation[n];
     } else {
       p = new((void*) gvp) TGeoRotation[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoRotation;
     } else {
       p = new((void*) gvp) TGeoRotation;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoRotation* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoRotation(*(TGeoRotation*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGeoRotation(*(TGeoRotation*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoRotation* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoRotation(*(TGeoMatrix*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGeoRotation(*(TGeoMatrix*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoRotation* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoRotation((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoRotation((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoRotation* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoRotation(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
   } else {
     p = new((void*) gvp) TGeoRotation(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoRotation* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoRotation(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   } else {
     p = new((void*) gvp) TGeoRotation(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoRotation& obj = ((TGeoRotation*) G__getstructoffset())->operator=(*(TGeoMatrix*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoRotation& obj = ((TGeoRotation*) G__getstructoffset())->operator=(*(TGeoRotation*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoRotation*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoRotation*) G__getstructoffset())->Determinant());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoRotation*) G__getstructoffset())->FastRotZ((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoRotation*) G__getstructoffset())->GetAngles(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoRotation*) G__getstructoffset())->GetAngles(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TGeoRotation*) G__getstructoffset())->GetPhiRotation((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TGeoRotation*) G__getstructoffset())->GetPhiRotation());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGeoRotation*) G__getstructoffset())->MultiplyBy((TGeoRotation*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoRotation*) G__getstructoffset())->MultiplyBy((TGeoRotation*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoRotation*) G__getstructoffset())->SetAngles((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoRotation*) G__getstructoffset())->SetAngles((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoRotation*) G__getstructoffset())->SetMatrix((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoRotation*) G__getstructoffset())->SetRotation(*(TGeoMatrix*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoRotation*) G__getstructoffset())->GetInverse((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoRotation::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoRotation::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoRotation::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoRotation::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoRotation*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoRotation::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoRotation::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoRotation::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_165_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoRotation::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoRotation G__TTGeoRotation;
static int G__G__Geom1_165_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[] (TGeoRotation*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoRotation*) (soff+(sizeof(TGeoRotation)*i)))->~G__TTGeoRotation();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoRotation*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoRotation*) (soff))->~G__TTGeoRotation();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoScale */
static int G__G__Geom1_166_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoScale* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoScale[n];
     } else {
       p = new((void*) gvp) TGeoScale[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoScale;
     } else {
       p = new((void*) gvp) TGeoScale;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_166_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoScale* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoScale(*(TGeoScale*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGeoScale(*(TGeoScale*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_166_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoScale* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoScale(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) TGeoScale(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_166_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoScale* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoScale(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
   } else {
     p = new((void*) gvp) TGeoScale(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_166_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoScale*) G__getstructoffset())->SetScale((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_166_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TGeoScale*) G__getstructoffset())->LocalToMaster((Double_t) G__double(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TGeoScale*) G__getstructoffset())->LocalToMaster((Double_t) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_166_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TGeoScale*) G__getstructoffset())->MasterToLocal((Double_t) G__double(libp->para[0]), (Double_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TGeoScale*) G__getstructoffset())->MasterToLocal((Double_t) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_166_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoScale::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_166_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoScale::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_166_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoScale::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_166_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoScale::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_166_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoScale*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_166_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoScale::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_166_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoScale::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_166_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoScale::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_166_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoScale::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoScale G__TTGeoScale;
static int G__G__Geom1_166_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[] (TGeoScale*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoScale*) (soff+(sizeof(TGeoScale)*i)))->~G__TTGeoScale();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoScale*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoScale*) (soff))->~G__TTGeoScale();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_166_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoScale* dest = (TGeoScale*) G__getstructoffset();
   *dest = *(TGeoScale*) libp->para[0].ref;
   const TGeoScale& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoCombiTrans */
static int G__G__Geom1_167_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCombiTrans* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoCombiTrans[n];
     } else {
       p = new((void*) gvp) TGeoCombiTrans[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoCombiTrans;
     } else {
       p = new((void*) gvp) TGeoCombiTrans;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCombiTrans* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoCombiTrans(*(TGeoCombiTrans*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGeoCombiTrans(*(TGeoCombiTrans*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCombiTrans* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoCombiTrans(*(TGeoMatrix*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGeoCombiTrans(*(TGeoMatrix*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCombiTrans* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoCombiTrans(*(TGeoTranslation*) libp->para[0].ref, *(TGeoRotation*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TGeoCombiTrans(*(TGeoTranslation*) libp->para[0].ref, *(TGeoRotation*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCombiTrans* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoCombiTrans((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoCombiTrans((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCombiTrans* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoCombiTrans(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TGeoRotation*) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TGeoCombiTrans(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (TGeoRotation*) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCombiTrans* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoCombiTrans(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (TGeoRotation*) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TGeoCombiTrans(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (TGeoRotation*) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoCombiTrans& obj = ((TGeoCombiTrans*) G__getstructoffset())->operator=(*(TGeoMatrix*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoCombiTrans& obj = ((TGeoCombiTrans*) G__getstructoffset())->operator=(*(TGeoCombiTrans*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoCombiTrans*) G__getstructoffset())->SetTranslation(*(TGeoTranslation*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoCombiTrans*) G__getstructoffset())->SetTranslation((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoCombiTrans*) G__getstructoffset())->SetTranslation((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoCombiTrans*) G__getstructoffset())->SetRotation(*(TGeoRotation*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoCombiTrans*) G__getstructoffset())->SetRotation((TGeoRotation*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_167_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoCombiTrans::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoCombiTrans::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoCombiTrans::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoCombiTrans::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoCombiTrans*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoCombiTrans::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoCombiTrans::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoCombiTrans::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_167_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoCombiTrans::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoCombiTrans G__TTGeoCombiTrans;
static int G__G__Geom1_167_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoCombiTrans*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoCombiTrans*) (soff+(sizeof(TGeoCombiTrans)*i)))->~G__TTGeoCombiTrans();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoCombiTrans*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoCombiTrans*) (soff))->~G__TTGeoCombiTrans();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoGenTrans */
static int G__G__Geom1_168_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoGenTrans* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoGenTrans[n];
     } else {
       p = new((void*) gvp) TGeoGenTrans[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoGenTrans;
     } else {
       p = new((void*) gvp) TGeoGenTrans;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_168_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoGenTrans* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoGenTrans((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoGenTrans((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_168_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoGenTrans* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoGenTrans(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (TGeoRotation*) G__int(libp->para[6]));
   } else {
     p = new((void*) gvp) TGeoGenTrans(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (TGeoRotation*) G__int(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_168_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoGenTrans* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoGenTrans(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (TGeoRotation*) G__int(libp->para[7]));
   } else {
     p = new((void*) gvp) TGeoGenTrans(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (TGeoRotation*) G__int(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_168_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoGenTrans*) G__getstructoffset())->SetScale((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_168_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoGenTrans*) G__getstructoffset())->SetScale((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_168_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGeoGenTrans*) G__getstructoffset())->Normalize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_168_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoGenTrans::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_168_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoGenTrans::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_168_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoGenTrans::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_168_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoGenTrans::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_168_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoGenTrans*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_168_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoGenTrans::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_168_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoGenTrans::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_168_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoGenTrans::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_168_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoGenTrans::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_168_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoGenTrans* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoGenTrans(*(TGeoGenTrans*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoGenTrans G__TTGeoGenTrans;
static int G__G__Geom1_168_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[] (TGeoGenTrans*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoGenTrans*) (soff+(sizeof(TGeoGenTrans)*i)))->~G__TTGeoGenTrans();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoGenTrans*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoGenTrans*) (soff))->~G__TTGeoGenTrans();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_168_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoGenTrans* dest = (TGeoGenTrans*) G__getstructoffset();
   *dest = *(TGeoGenTrans*) libp->para[0].ref;
   const TGeoGenTrans& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoIdentity */
static int G__G__Geom1_169_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoIdentity* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoIdentity[n];
     } else {
       p = new((void*) gvp) TGeoIdentity[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoIdentity;
     } else {
       p = new((void*) gvp) TGeoIdentity;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoIdentity));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoIdentity* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoIdentity((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoIdentity((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoIdentity));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoIdentity::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoIdentity::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoIdentity::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoIdentity::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoIdentity*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoIdentity::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoIdentity::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoIdentity::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_169_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoIdentity::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_169_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoIdentity* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoIdentity(*(TGeoIdentity*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoIdentity));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoIdentity G__TTGeoIdentity;
static int G__G__Geom1_169_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[] (TGeoIdentity*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoIdentity*) (soff+(sizeof(TGeoIdentity)*i)))->~G__TTGeoIdentity();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoIdentity*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoIdentity*) (soff))->~G__TTGeoIdentity();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_169_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoIdentity* dest = (TGeoIdentity*) G__getstructoffset();
   *dest = *(TGeoIdentity*) libp->para[0].ref;
   const TGeoIdentity& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoBBox */
static int G__G__Geom1_172_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoBBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoBBox[n];
     } else {
       p = new((void*) gvp) TGeoBBox[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoBBox;
     } else {
       p = new((void*) gvp) TGeoBBox;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoBBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoBBox(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TGeoBBox(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoBBox(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TGeoBBox(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoBBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoBBox(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TGeoBBox(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoBBox(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TGeoBBox(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoBBox* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoBBox((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoBBox((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGeoBBox::AreOverlapping((TGeoBBox*) G__int(libp->para[0]), (TGeoMatrix*) G__int(libp->para[1])
, (TGeoBBox*) G__int(libp->para[2]), (TGeoMatrix*) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGeoBBox::Contains((Double_t*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t*) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) TGeoBBox::DistFromInside(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) TGeoBBox::DistFromInside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t*) G__int(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letdouble(result7, 100, (double) TGeoBBox::DistFromOutside(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letdouble(result7, 100, (double) TGeoBBox::DistFromOutside((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t*) G__int(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TGeoBBox*) G__getstructoffset())->GetFacetArea((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TGeoBBox*) G__getstructoffset())->GetFacetArea());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoBBox*) G__getstructoffset())->GetPointsOnFacet((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoBBox*) G__getstructoffset())->GetDX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoBBox*) G__getstructoffset())->GetDY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoBBox*) G__getstructoffset())->GetDZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoBBox*) G__getstructoffset())->GetOrigin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoBBox*) G__getstructoffset())->IsNullBox());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGeoBBox*) G__getstructoffset())->SetBoxDimensions((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGeoBBox*) G__getstructoffset())->SetBoxDimensions((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoBBox*) G__getstructoffset())->SetBoxPoints((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoBBox::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoBBox::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoBBox::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoBBox::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoBBox*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoBBox::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoBBox::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoBBox::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_172_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoBBox::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_172_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoBBox* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoBBox(*(TGeoBBox*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoBBox G__TTGeoBBox;
static int G__G__Geom1_172_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoBBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoBBox*) (soff+(sizeof(TGeoBBox)*i)))->~G__TTGeoBBox();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoBBox*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoBBox*) (soff))->~G__TTGeoBBox();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_172_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoBBox* dest = (TGeoBBox*) G__getstructoffset();
   *dest = *(TGeoBBox*) libp->para[0].ref;
   const TGeoBBox& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoVolume */
static int G__G__Geom1_173_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoVolume* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoVolume[n];
     } else {
       p = new((void*) gvp) TGeoVolume[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoVolume;
     } else {
       p = new((void*) gvp) TGeoVolume;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoVolume* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoVolume(
(const char*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoMedium*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGeoVolume(
(const char*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoMedium*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoVolume((const char*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoVolume((const char*) G__int(libp->para[0]), (TGeoShape*) 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__Geom1LN_TGeoVolume));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoVolume*) G__getstructoffset())->cd((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoVolume*) G__getstructoffset())->Capacity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->CheckShapes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->ClearNodes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->ClearShape();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->CleanAll();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_173_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoVolume*) G__getstructoffset())->CloneNodesAndConnect((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((const TGeoVolume*) G__getstructoffset())->CheckGeometry((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((const TGeoVolume*) G__getstructoffset())->CheckGeometry((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((const TGeoVolume*) G__getstructoffset())->CheckGeometry((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TGeoVolume*) G__getstructoffset())->CheckGeometry((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const TGeoVolume*) G__getstructoffset())->CheckGeometry();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TGeoVolume*) G__getstructoffset())->CheckOverlaps((Double_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TGeoVolume*) G__getstructoffset())->CheckOverlaps((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const TGeoVolume*) G__getstructoffset())->CheckOverlaps();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TGeoVolume*) G__getstructoffset())->CountNodes((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TGeoVolume*) G__getstructoffset())->CountNodes((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TGeoVolume*) G__getstructoffset())->CountNodes());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->Contains((Double_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsAssembly());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsRunTime());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsVolumeMulti());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGeoVolume*) G__getstructoffset())->AddNode((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGeoVolume*) G__getstructoffset())->AddNode((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGeoVolume*) G__getstructoffset())->AddNode((TGeoVolume*) 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__Geom1_173_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGeoVolume*) G__getstructoffset())->AddNodeOffset((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGeoVolume*) G__getstructoffset())->AddNodeOffset((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGeoVolume*) G__getstructoffset())->AddNodeOffset((TGeoVolume*) 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__Geom1_173_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGeoVolume*) G__getstructoffset())->AddNodeOverlap((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGeoVolume*) G__getstructoffset())->AddNodeOverlap((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGeoVolume*) G__getstructoffset())->AddNodeOverlap((TGeoVolume*) 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__Geom1_173_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->Divide(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])
, (Option_t*) G__int(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->Divide((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->Divide((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoVolume*) G__getstructoffset())->DrawOnly((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoVolume*) G__getstructoffset())->DrawOnly();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 9:
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->LegoPlot(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Option_t*) G__int(libp->para[8])));
      break;
   case 8:
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->LegoPlot(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])));
      break;
   case 7:
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->LegoPlot(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->LegoPlot((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->LegoPlot((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->LegoPlot((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->LegoPlot((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->LegoPlot((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->LegoPlot((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->LegoPlot());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoVolume*) G__getstructoffset())->PrintNodes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoVolume*) G__getstructoffset())->PrintVoxels();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->ReplayCreation((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsActive());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsActiveDaughters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsAdded());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsReplicated());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsSelected());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsCylVoxels());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsXYZVoxels());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsTopVolume());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsVisibleDaughters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsVisContainers());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsVisLeaves());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsVisOnly());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsAllInvisible());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsRaytracing());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) TGeoVolume::Import((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) TGeoVolume::Import((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TGeoVolume::Import((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TGeoVolume*) G__getstructoffset())->Export((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TGeoVolume*) G__getstructoffset())->Export((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TGeoVolume*) G__getstructoffset())->Export((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoVolume*) G__getstructoffset())->FindNode((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoVolume*) G__getstructoffset())->FindOverlaps();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->FindMatrixOfDaughterVolume((TGeoVolume*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoVolume*) G__getstructoffset())->GetCurrentNodeIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoVolume*) G__getstructoffset())->GetNextNodeIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->GetNodes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoVolume*) G__getstructoffset())->GetNdaughters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoVolume*) G__getstructoffset())->GetNtotal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoVolume*) G__getstructoffset())->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__Geom1_173_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoVolume*) G__getstructoffset())->GetIndex((TGeoNode*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoVolume*) G__getstructoffset())->GetNode((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoVolume*) G__getstructoffset())->GetNode((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoVolume*) G__getstructoffset())->GetNodeIndex((TGeoNode*) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoVolume*) G__getstructoffset())->GetNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->GetOptimalVoxels());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGeoVolume*) G__getstructoffset())->GetPointerName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((const TGeoVolume*) G__getstructoffset())->GetTransparency());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_173_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->GrabFocus();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->Gsord((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->IsStyleDefault());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoVolume*) G__getstructoffset())->InspectMaterial();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoVolume*) G__getstructoffset())->InspectShape();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->MakeCopyVolume((TGeoShape*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->MakeCopyNodes((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TGeoVolume*) G__getstructoffset())->MakeReflectedVolume((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TGeoVolume*) G__getstructoffset())->MakeReflectedVolume());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGeoVolume*) G__getstructoffset())->OptimizeVoxels());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGeoVolume*) G__getstructoffset())->RandomPoints((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoVolume*) G__getstructoffset())->RandomPoints((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoVolume*) G__getstructoffset())->RandomPoints();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGeoVolume*) G__getstructoffset())->RandomRays((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGeoVolume*) G__getstructoffset())->RandomRays((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGeoVolume*) G__getstructoffset())->RandomRays((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoVolume*) G__getstructoffset())->RandomRays((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoVolume*) G__getstructoffset())->RandomRays();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoVolume*) G__getstructoffset())->Raytrace((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoVolume*) G__getstructoffset())->Raytrace();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoVolume*) G__getstructoffset())->RegisterYourself((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoVolume*) G__getstructoffset())->RegisterYourself();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->RemoveNode((TGeoNode*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->ReplaceNode((TGeoNode*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]), (TGeoMedium*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->ReplaceNode((TGeoNode*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->ReplaceNode((TGeoNode*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGeoVolume*) G__getstructoffset())->ReplaceNode((TGeoNode*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoVolume*) G__getstructoffset())->SelectVolume((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoVolume*) G__getstructoffset())->SelectVolume();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoVolume*) G__getstructoffset())->SetActivity((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoVolume*) G__getstructoffset())->SetActivity();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoVolume*) G__getstructoffset())->SetActiveDaughters((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoVolume*) G__getstructoffset())->SetActiveDaughters();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->SetAsTopVolume();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->SetAdded();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->SetReplicated();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->SetCurrentPoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoVolume*) G__getstructoffset())->SetCylVoxels((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoVolume*) G__getstructoffset())->SetCylVoxels();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->SetNodes((TObjArray*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->SetShape((TGeoShape*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoVolume*) G__getstructoffset())->SetTransparency((Char_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoVolume*) G__getstructoffset())->SetTransparency();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->SetField((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->SetOption((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->SetAttVisibility((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->SetInvisible();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->SetMedium((TGeoMedium*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->SetVoxelFinder((TGeoVoxelFinder*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->SetFinder((TGeoPatternFinder*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->SetNumber((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->SetNtotal((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->SortNodes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->UnmarkSaved();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVolume*) G__getstructoffset())->Valid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoVolume*) G__getstructoffset())->VisibleDaughters((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoVolume*) G__getstructoffset())->VisibleDaughters();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoVolume*) G__getstructoffset())->InvisibleAll((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoVolume*) G__getstructoffset())->InvisibleAll();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->Voxelize((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((TGeoVolume*) G__getstructoffset())->Weight((Double_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((TGeoVolume*) G__getstructoffset())->Weight((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((TGeoVolume*) G__getstructoffset())->Weight());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoVolume*) G__getstructoffset())->WeightA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoVolume::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoVolume::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoVolume::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoVolume::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolume*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoVolume::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoVolume::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoVolume::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_173_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoVolume::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoVolume G__TTGeoVolume;
static int G__G__Geom1_173_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoVolume*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoVolume*) (soff+(sizeof(TGeoVolume)*i)))->~G__TTGeoVolume();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoVolume*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoVolume*) (soff))->~G__TTGeoVolume();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoNode */
static int G__G__Geom1_177_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNode*) G__getstructoffset())->cd();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGeoNode*) G__getstructoffset())->CheckOverlaps((Double_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoNode*) G__getstructoffset())->CheckOverlaps((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoNode*) G__getstructoffset())->CheckOverlaps();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNode*) G__getstructoffset())->CheckShapes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TGeoNode*) G__getstructoffset())->CountDaughters((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TGeoNode*) G__getstructoffset())->CountDaughters());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoNode*) G__getstructoffset())->DrawOnly((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoNode*) G__getstructoffset())->DrawOnly();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNode*) G__getstructoffset())->DrawOverlaps();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNode*) G__getstructoffset())->FillIdArray(*(Int_t*) G__Intref(&libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
, (Int_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoNode*) G__getstructoffset())->FindNode((TGeoNode*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoNode*) G__getstructoffset())->GetByteCount());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoNode*) G__getstructoffset())->GetDaughter((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_177_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoNode*) G__getstructoffset())->GetColour());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoNode*) G__getstructoffset())->GetIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Geom1_177_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoNode*) G__getstructoffset())->GetNdaughters());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_177_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoNode*) G__getstructoffset())->GetNumber());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TGeoNode*) G__getstructoffset())->GetOverlaps(*(Int_t*) G__Intref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_177_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoNode*) G__getstructoffset())->GetOptimalVoxels());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNode*) G__getstructoffset())->InspectNode();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNode*) G__getstructoffset())->IsOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNode*) G__getstructoffset())->IsOnScreen());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNode*) G__getstructoffset())->IsOverlapping());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNode*) G__getstructoffset())->IsVirtual());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNode*) G__getstructoffset())->IsVisible());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNode*) G__getstructoffset())->IsVisDaughters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNode*) G__getstructoffset())->MayOverlap((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_177_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TGeoNode*) G__getstructoffset())->Safety((Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TGeoNode*) G__getstructoffset())->Safety((Double_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNode*) G__getstructoffset())->SaveAttributes(*(ostream*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNode*) G__getstructoffset())->SetCurrentPoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNode*) G__getstructoffset())->SetVolume((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNode*) G__getstructoffset())->SetNumber((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoNode*) G__getstructoffset())->SetOverlapping((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoNode*) G__getstructoffset())->SetOverlapping();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNode*) G__getstructoffset())->SetVirtual();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNode*) G__getstructoffset())->SetInvisible();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNode*) G__getstructoffset())->SetAllInvisible();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNode*) G__getstructoffset())->SetMotherVolume((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNode*) G__getstructoffset())->SetOverlaps((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__Geom1_177_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNode*) G__getstructoffset())->MasterToLocal((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNode*) G__getstructoffset())->MasterToLocalVect((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNode*) G__getstructoffset())->LocalToMaster((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNode*) G__getstructoffset())->LocalToMasterVect((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNode*) G__getstructoffset())->PrintCandidates();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNode*) G__getstructoffset())->PrintOverlaps();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoNode*) G__getstructoffset())->VisibleDaughters((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoNode*) G__getstructoffset())->VisibleDaughters();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoNode::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoNode::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoNode::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoNode::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNode*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoNode::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoNode::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoNode::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_177_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoNode::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoNode G__TTGeoNode;
static int G__G__Geom1_177_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoNode*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoNode*) (soff+(sizeof(TGeoNode)*i)))->~G__TTGeoNode();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoNode*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoNode*) (soff))->~G__TTGeoNode();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoVoxelFinder */
static int G__G__Geom1_179_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoVoxelFinder* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoVoxelFinder[n];
     } else {
       p = new((void*) gvp) TGeoVoxelFinder[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoVoxelFinder;
     } else {
       p = new((void*) gvp) TGeoVoxelFinder;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoVoxelFinder* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoVoxelFinder((TGeoVolume*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoVoxelFinder((TGeoVolume*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVoxelFinder*) G__getstructoffset())->CreateCheckList();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoVoxelFinder*) G__getstructoffset())->DaughterToMother((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TGeoVoxelFinder*) G__getstructoffset())->Efficiency());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((TGeoVoxelFinder*) G__getstructoffset())->GetCheckList((Double_t*) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TGeoVoxelFinder*) G__getstructoffset())->GetCheckList(*(Int_t*) G__Intref(&libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((TGeoVoxelFinder*) G__getstructoffset())->GetNextCandidates((Double_t*) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoVoxelFinder*) G__getstructoffset())->FindOverlaps((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVoxelFinder*) G__getstructoffset())->IsInvalid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVoxelFinder*) G__getstructoffset())->NeedRebuild());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoVoxelFinder*) G__getstructoffset())->GetBoxes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoVoxelFinder*) G__getstructoffset())->IsSafeVoxel((Double_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoVoxelFinder*) G__getstructoffset())->PrintVoxelLimits((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoVoxelFinder*) G__getstructoffset())->SetInvalid((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoVoxelFinder*) G__getstructoffset())->SetInvalid();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoVoxelFinder*) G__getstructoffset())->SetNeedRebuild((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoVoxelFinder*) G__getstructoffset())->SetNeedRebuild();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((TGeoVoxelFinder*) G__getstructoffset())->GetNextVoxel((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVoxelFinder*) G__getstructoffset())->SortCrossedVoxels((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoVoxelFinder*) G__getstructoffset())->Voxelize((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoVoxelFinder*) G__getstructoffset())->Voxelize();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoVoxelFinder::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoVoxelFinder::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoVoxelFinder::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoVoxelFinder::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVoxelFinder*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoVoxelFinder::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoVoxelFinder::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoVoxelFinder::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_179_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoVoxelFinder::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoVoxelFinder G__TTGeoVoxelFinder;
static int G__G__Geom1_179_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoVoxelFinder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoVoxelFinder*) (soff+(sizeof(TGeoVoxelFinder)*i)))->~G__TTGeoVoxelFinder();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoVoxelFinder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoVoxelFinder*) (soff))->~G__TTGeoVoxelFinder();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoManager */
static int G__G__Geom1_180_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoManager* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoManager[n];
     } else {
       p = new((void*) gvp) TGeoManager[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoManager;
     } else {
       p = new((void*) gvp) TGeoManager;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoManager* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoManager((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGeoManager((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->AddMaterial((TGeoMaterial*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->AddOverlap((TNamed*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->AddTransformation((TGeoMatrix*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->AddShape((TGeoShape*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->AddTrack((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TObject*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->AddTrack((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->AddTrack((TVirtualGeoTrack*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->AddVolume((TGeoVolume*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->AddNavigator((TGeoNavigator*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->ClearOverlaps();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->RegisterMatrix((TGeoMatrix*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SortOverlaps();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetVisibility((TObject*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 103, (long) ((TGeoManager*) G__getstructoffset())->cd((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((TGeoManager*) G__getstructoffset())->cd());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->CheckPath((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->CdNode((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->CdDown((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->CdUp();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->CdTop();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->CdNext();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoManager*) G__getstructoffset())->GetBranchNames((Int_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoManager*) G__getstructoffset())->GetBranchNumbers((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__Geom1_180_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoManager*) G__getstructoffset())->GetBranchOnlys((Int_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetNmany());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGeoManager*) G__getstructoffset())->GetPdgName((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetPdgName((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->Edit((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->Edit();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->BombTranslation((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->UnbombTranslation((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->ClearAttributes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->DefaultAngles();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->DefaultColors();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_180_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetNsegments());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->GetGeomPainter());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_180_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetBombMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoManager*) G__getstructoffset())->GetBombFactors(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetMaxVisNodes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->GetTminTmax(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoManager*) G__getstructoffset())->GetTmax());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_180_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoManager*) G__getstructoffset())->GetVisDensity());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetVisLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetVisOption());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsInPhiRange());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsDrawingExtra());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsNodeSelectable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsVisLeaves());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoManager*) G__getstructoffset())->ModifiedPad();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->OptimizeVoxels((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->OptimizeVoxels();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetClipping((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetClipping();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetClippingShape((TGeoShape*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetExplodedView((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetExplodedView();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGeoManager*) G__getstructoffset())->SetPhiRange((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetPhiRange((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetPhiRange();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetNsegments((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGeoManager*) G__getstructoffset())->SetCurrentNavigator((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGeoManager*) G__getstructoffset())->SetBombFactors((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGeoManager*) G__getstructoffset())->SetBombFactors((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGeoManager*) G__getstructoffset())->SetBombFactors((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetBombFactors((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetBombFactors();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetPaintVolume((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetTopVisible((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetTopVisible();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGeoManager*) G__getstructoffset())->SetTminTmax((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetTminTmax((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetTminTmax();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetDrawExtraPaths((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetDrawExtraPaths();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetNodeSelectable((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetNodeSelectable();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetVisDensity((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetVisDensity();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetVisLevel((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetVisLevel();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetVisOption((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetVisOption();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->ViewLeaves((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->ViewLeaves();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->SaveAttributes((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SaveAttributes();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->RestoreMasterVolume();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetMaxVisNodes((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetMaxVisNodes();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGeoManager*) G__getstructoffset())->AnimateTracks((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGeoManager*) G__getstructoffset())->AnimateTracks((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGeoManager*) G__getstructoffset())->AnimateTracks((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoManager*) G__getstructoffset())->AnimateTracks((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->AnimateTracks();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGeoManager*) G__getstructoffset())->CheckBoundaryErrors((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoManager*) G__getstructoffset())->CheckBoundaryErrors((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->CheckBoundaryErrors();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->CheckBoundaryReference((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->CheckBoundaryReference();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TGeoManager*) G__getstructoffset())->CheckGeometryFull((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TGeoManager*) G__getstructoffset())->CheckGeometryFull((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGeoManager*) G__getstructoffset())->CheckGeometryFull((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGeoManager*) G__getstructoffset())->CheckGeometryFull((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoManager*) G__getstructoffset())->CheckGeometryFull((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->CheckGeometryFull();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->CheckGeometry((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->CheckGeometry();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGeoManager*) G__getstructoffset())->CheckOverlaps((Double_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoManager*) G__getstructoffset())->CheckOverlaps((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->CheckOverlaps();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGeoManager*) G__getstructoffset())->CheckPoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGeoManager*) G__getstructoffset())->CheckPoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGeoManager*) G__getstructoffset())->CheckPoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoManager*) G__getstructoffset())->CheckPoint((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->CheckPoint();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->ConvertReflections();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->DrawCurrentPoint((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->DrawCurrentPoint();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->DrawTracks((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->DrawTracks();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetParticleName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGeoManager*) G__getstructoffset())->GetParticleName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->DrawPath((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoManager*) G__getstructoffset())->PrintOverlaps();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TGeoManager*) G__getstructoffset())->RandomPoints((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGeoManager*) G__getstructoffset())->RandomPoints((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoManager*) G__getstructoffset())->RandomPoints((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGeoManager*) G__getstructoffset())->RandomRays((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGeoManager*) G__getstructoffset())->RandomRays((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGeoManager*) G__getstructoffset())->RandomRays((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoManager*) G__getstructoffset())->RandomRays((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->RandomRays();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->SamplePoints((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, (Double_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->SamplePoints((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->SamplePoints((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetNmeshPoints((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetNmeshPoints();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetCheckedNode((TGeoNode*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGeoManager*) G__getstructoffset())->Test((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoManager*) G__getstructoffset())->Test((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->Test();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->TestOverlaps((const char*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->TestOverlaps();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((TGeoManager*) G__getstructoffset())->Weight((Double_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((TGeoManager*) G__getstructoffset())->Weight((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((TGeoManager*) G__getstructoffset())->Weight());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->Division(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Option_t*) G__int(libp->para[7])));
      break;
   case 7:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->Division(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->Division((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->Matrix(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->Material(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->Material((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->Material((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->Mixture(
(const char*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->Mixture(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->Medium(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 10:
      ((TGeoManager*) G__getstructoffset())->Node(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (Float_t*) G__int(libp->para[8]), (Int_t) G__int(libp->para[9]));
      G__setnull(result7);
      break;
   case 9:
      ((TGeoManager*) G__getstructoffset())->Node(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (Float_t*) G__int(libp->para[8]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 10:
      ((TGeoManager*) G__getstructoffset())->Node(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (Double_t*) G__int(libp->para[8]), (Int_t) G__int(libp->para[9]));
      G__setnull(result7);
      break;
   case 9:
      ((TGeoManager*) G__getstructoffset())->Node(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (Double_t*) G__int(libp->para[8]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->Volume((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->Volume((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->Volume((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->Volume((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetVolumeAttribute((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->BuildDefaultMaterials();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->CloseGeometry((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->CloseGeometry();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsClosed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeArb8((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeArb8((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeBox((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeCone(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeCons(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeCtub(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
, (Double_t) G__double(libp->para[12])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeEltu((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeGtra(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
, (Double_t) G__double(libp->para[12]), (Double_t) G__double(libp->para[13])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakePara(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakePcon((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeParaboloid((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeHype(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakePgon((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeSphere(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])));
      break;
   case 7:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeSphere(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeSphere((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeSphere((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeSphere((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeTorus(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeTorus((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeTorus((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeTrap(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
, (Double_t) G__double(libp->para[12])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeTrd1((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeTrd2(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeTube((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeTubs(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeXtru((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->SetAlignableEntry((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->SetAlignableEntry((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->GetAlignableEntry((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->GetAlignableEntry((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->GetAlignableEntryByUID((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetNAlignable((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetNAlignable());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeAlignablePN((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_145(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeAlignablePN((TGeoPNEntry*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_146(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakePhysicalNode((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakePhysicalNode());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_147(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->ClearPhysicalNodes((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->ClearPhysicalNodes();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->RefreshPhysicalNodes((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->RefreshPhysicalNodes();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeTrack((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TObject*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_150(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeVolumeAssembly((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_151(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->MakeVolumeMulti((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetTopVolume((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_153(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->CrossBoundaryAndLocate((Bool_t) G__int(libp->para[0]), (TGeoNode*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_154(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->FindNextBoundary((Double_t) G__double(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->FindNextBoundary((Double_t) G__double(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->FindNextBoundary((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->FindNextBoundary());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_155(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->FindNextDaughterBoundary((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), (Bool_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->FindNextDaughterBoundary((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_156(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->FindNextBoundaryAndStep((Double_t) G__double(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->FindNextBoundaryAndStep((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->FindNextBoundaryAndStep());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_157(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->FindNode((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->FindNode());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_158(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->FindNode((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_159(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 68, (long) ((TGeoManager*) G__getstructoffset())->FindNormal((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 68, (long) ((TGeoManager*) G__getstructoffset())->FindNormal());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_160(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGeoManager*) G__getstructoffset())->FindNormalFast());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_161(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->InitTrack((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_162(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->InitTrack((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_163(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->ResetState();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_164(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((TGeoManager*) G__getstructoffset())->Safety((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((TGeoManager*) G__getstructoffset())->Safety());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_165(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->SearchNode((Bool_t) G__int(libp->para[0]), (TGeoNode*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->SearchNode((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->SearchNode());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_166(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->Step((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->Step((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->Step());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_167(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->DisableInactiveVolumes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_168(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->EnableInactiveVolumes();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_169(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetCurrentTrack((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_170(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetCurrentTrack((TVirtualGeoTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_171(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetNtracks());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_172(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->GetCurrentTrack());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_173(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->GetLastTrack());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_174(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoManager*) G__getstructoffset())->GetLastPoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_175(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->GetTrack((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_176(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetTrackIndex((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_177(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->GetTrackOfId((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_178(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->FindTrackWithId((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_179(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->GetParentTrackOfId((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_180(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->GetVirtualLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_181(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGeoManager*) G__getstructoffset())->GotoSafeLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_182(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetSafeLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_183(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoManager*) G__getstructoffset())->GetSafeDistance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_184(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoManager*) G__getstructoffset())->GetLastSafety());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_185(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoManager*) G__getstructoffset())->GetStep());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_186(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoManager*) G__getstructoffset())->InspectState();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_187(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsAnimatingTracks());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_188(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsCheckingOverlaps());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_189(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsMatrixTransform());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_190(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsMatrixReflection());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_191(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) ((TGeoManager*) G__getstructoffset())->IsSameLocation((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) ((TGeoManager*) G__getstructoffset())->IsSameLocation((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_192(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsSameLocation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_193(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsSamePoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_194(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsStartSafe());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_195(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetCheckingOverlaps((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetCheckingOverlaps();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_196(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetStartSafe((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetStartSafe();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_197(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetMatrixTransform((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetMatrixTransform();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_198(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetMatrixReflection((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetMatrixReflection();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_199(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetStep((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_200(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsCurrentOverlapping());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_201(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsEntering());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_202(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsExiting());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_203(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsStepEntering());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_204(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsStepExiting());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_205(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsOutside());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_206(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsOnBoundary());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_207(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsNullStep());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_208(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsActivityEnabled());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_209(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetOutside((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetOutside();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_210(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->CleanGarbage();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_211(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->ClearShape((TGeoShape*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_212(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->ClearTracks();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_213(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->RemoveMaterial((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_214(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->ResetUserData();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_215(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->CountNodes((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->CountNodes((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->CountNodes((TGeoVolume*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->CountNodes());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_217(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoManager::Parse((const char*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, *(TString*) libp->para[3].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_218(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->ReplaceVolume((TGeoVolume*) G__int(libp->para[0]), (TGeoVolume*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_219(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->TransformVolumeToAssembly((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_220(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 66, (long) ((TGeoManager*) G__getstructoffset())->GetBits());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_221(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->GetByteCount((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->GetByteCount());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_222(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((TGeoManager*) G__getstructoffset())->GetIntBuffer((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_223(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGeoManager*) G__getstructoffset())->GetDblBuffer((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_224(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetAllIndex();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_225(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->Export((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->Export((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->Export((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_226(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoManager::LockGeometry();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_227(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoManager::UnlockGeometry();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_228(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoManager::GetVerboseLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_229(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoManager::SetVerboseLevel((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_230(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) TGeoManager::Import((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) TGeoManager::Import((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TGeoManager::Import((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_231(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGeoManager::IsLocked());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_232(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoManager*) G__getstructoffset())->IsStreamingVoxels());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_233(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->GetListOfNodes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_234(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->GetListOfPhysicalNodes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_235(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->GetListOfOverlaps());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

static int G__G__Geom1_180_0_246(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->GetElementTable());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_247(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->DoBackupState();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_248(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->DoRestoreState();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_249(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->GetNode((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_250(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetNodeId());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_180_0_252(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->GetMother((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->GetMother());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_253(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->GetMotherMatrix((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->GetMotherMatrix());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_254(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->GetHMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Geom1_180_0_259(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetCurrentNodeId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_260(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoManager*) G__getstructoffset())->GetCurrentPoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_261(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoManager*) G__getstructoffset())->GetCurrentDirection());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_180_0_263(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoManager*) G__getstructoffset())->GetCldirChecked());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_264(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoManager*) G__getstructoffset())->GetCldir());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_265(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoManager*) G__getstructoffset())->GetNormal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_266(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_267(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetMaxLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_268(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGeoManager*) G__getstructoffset())->GetPath());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_269(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetStackLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__Geom1_180_0_273(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->GetPhysicalNode((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_274(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetCurrentPoint((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_275(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetCurrentPoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_276(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetLastPoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_277(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetCurrentDirection((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_278(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetCurrentDirection((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_279(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SetCldirChecked((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_280(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoManager*) G__getstructoffset())->LocalToMaster((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_281(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoManager*) G__getstructoffset())->LocalToMasterVect((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_282(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoManager*) G__getstructoffset())->LocalToMasterBomb((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_283(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoManager*) G__getstructoffset())->MasterToLocal((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_284(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoManager*) G__getstructoffset())->MasterToLocalVect((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_285(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoManager*) G__getstructoffset())->MasterToLocalBomb((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_286(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoManager*) G__getstructoffset())->MasterToTop((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_287(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoManager*) G__getstructoffset())->TopToMaster((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_288(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->FindDuplicateMaterial((TGeoMaterial*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_289(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->FindVolumeFast((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGeoManager*) G__getstructoffset())->FindVolumeFast((const char*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_290(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->GetMaterial((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_291(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->GetMaterial((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_292(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->GetMedium((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_293(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->GetMedium((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_294(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetMaterialIndex((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_295(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->GetVolume((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_296(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoManager*) G__getstructoffset())->GetVolume((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_297(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoManager*) G__getstructoffset())->GetUID((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_298(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->GetNNodes());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_180_0_300(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->SetAnimateTracks((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->SetAnimateTracks();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_301(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 107, (long) ((TGeoManager*) G__getstructoffset())->SizeOf((TGeoNode*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_302(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->SelectTrackingMedia();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_303(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->PushPath((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->PushPath());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_304(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGeoManager*) G__getstructoffset())->PopPath());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_305(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGeoManager*) G__getstructoffset())->PopPath((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_306(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->PushPoint((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TGeoManager*) G__getstructoffset())->PushPoint());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_307(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGeoManager*) G__getstructoffset())->PopPoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_308(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGeoManager*) G__getstructoffset())->PopPoint((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_309(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoManager*) G__getstructoffset())->PopDummy((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoManager*) G__getstructoffset())->PopDummy();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_310(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoManager::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_311(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoManager::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_312(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoManager::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_313(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoManager::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_317(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_318(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoManager::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_319(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoManager::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_320(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoManager::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_180_0_321(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoManager::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoManager G__TTGeoManager;
static int G__G__Geom1_180_0_322(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoManager*) (soff+(sizeof(TGeoManager)*i)))->~G__TTGeoManager();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoManager*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoManager*) (soff))->~G__TTGeoManager();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoVolumeMulti */
static int G__G__Geom1_182_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoVolumeMulti* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoVolumeMulti[n];
     } else {
       p = new((void*) gvp) TGeoVolumeMulti[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoVolumeMulti;
     } else {
       p = new((void*) gvp) TGeoVolumeMulti;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_182_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoVolumeMulti* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoVolumeMulti((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoVolumeMulti((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoVolumeMulti((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGeoVolumeMulti((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__Geom1LN_TGeoVolumeMulti));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_182_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolumeMulti*) G__getstructoffset())->AddVolume((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_182_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoVolumeMulti*) G__getstructoffset())->GetVolume((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_182_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoVolumeMulti*) G__getstructoffset())->GetNvolumes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_182_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoVolumeMulti*) G__getstructoffset())->GetAxis());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_182_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoVolumeMulti*) G__getstructoffset())->GetNdiv());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_182_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoVolumeMulti*) G__getstructoffset())->GetStart());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_182_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoVolumeMulti*) G__getstructoffset())->GetStep());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_182_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoVolumeMulti::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_182_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoVolumeMulti::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_182_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoVolumeMulti::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_182_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoVolumeMulti::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_182_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolumeMulti*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_182_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoVolumeMulti::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_182_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoVolumeMulti::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_182_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoVolumeMulti::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_182_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoVolumeMulti::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoVolumeMulti G__TTGeoVolumeMulti;
static int G__G__Geom1_182_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoVolumeMulti*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoVolumeMulti*) (soff+(sizeof(TGeoVolumeMulti)*i)))->~G__TTGeoVolumeMulti();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoVolumeMulti*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoVolumeMulti*) (soff))->~G__TTGeoVolumeMulti();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoVolumeAssembly */
static int G__G__Geom1_183_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoVolumeAssembly* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoVolumeAssembly[n];
     } else {
       p = new((void*) gvp) TGeoVolumeAssembly[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoVolumeAssembly;
     } else {
       p = new((void*) gvp) TGeoVolumeAssembly;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_183_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoVolumeAssembly* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoVolumeAssembly((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoVolumeAssembly((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_183_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoVolumeAssembly::MakeAssemblyFromVolume((TGeoVolume*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_183_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolumeAssembly*) G__getstructoffset())->SetCurrentNodeIndex((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_183_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolumeAssembly*) G__getstructoffset())->SetNextNodeIndex((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_183_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoVolumeAssembly::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_183_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoVolumeAssembly::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_183_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoVolumeAssembly::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_183_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoVolumeAssembly::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_183_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoVolumeAssembly*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_183_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoVolumeAssembly::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_183_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoVolumeAssembly::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_183_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoVolumeAssembly::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_183_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoVolumeAssembly::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_183_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoVolumeAssembly* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoVolumeAssembly(*(TGeoVolumeAssembly*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoVolumeAssembly G__TTGeoVolumeAssembly;
static int G__G__Geom1_183_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[] (TGeoVolumeAssembly*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoVolumeAssembly*) (soff+(sizeof(TGeoVolumeAssembly)*i)))->~G__TTGeoVolumeAssembly();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoVolumeAssembly*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoVolumeAssembly*) (soff))->~G__TTGeoVolumeAssembly();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoNodeMatrix */
static int G__G__Geom1_199_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoNodeMatrix* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoNodeMatrix[n];
     } else {
       p = new((void*) gvp) TGeoNodeMatrix[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoNodeMatrix;
     } else {
       p = new((void*) gvp) TGeoNodeMatrix;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoNodeMatrix* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoNodeMatrix((TGeoVolume*) G__int(libp->para[0]), (TGeoMatrix*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGeoNodeMatrix((TGeoVolume*) G__int(libp->para[0]), (TGeoMatrix*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNodeMatrix*) G__getstructoffset())->SetMatrix((TGeoMatrix*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoNodeMatrix::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoNodeMatrix::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoNodeMatrix::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoNodeMatrix::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNodeMatrix*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoNodeMatrix::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoNodeMatrix::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoNodeMatrix::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_199_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoNodeMatrix::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoNodeMatrix G__TTGeoNodeMatrix;
static int G__G__Geom1_199_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[] (TGeoNodeMatrix*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoNodeMatrix*) (soff+(sizeof(TGeoNodeMatrix)*i)))->~G__TTGeoNodeMatrix();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoNodeMatrix*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoNodeMatrix*) (soff))->~G__TTGeoNodeMatrix();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoNodeOffset */
static int G__G__Geom1_200_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoNodeOffset* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoNodeOffset[n];
     } else {
       p = new((void*) gvp) TGeoNodeOffset[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoNodeOffset;
     } else {
       p = new((void*) gvp) TGeoNodeOffset;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoNodeOffset* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoNodeOffset(
(TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) TGeoNodeOffset(
(TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoNodeOffset*) G__getstructoffset())->GetOffset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNodeOffset*) G__getstructoffset())->SetFinder((TGeoPatternFinder*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoNodeOffset::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoNodeOffset::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoNodeOffset::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoNodeOffset::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNodeOffset*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoNodeOffset::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoNodeOffset::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoNodeOffset::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_200_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoNodeOffset::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoNodeOffset G__TTGeoNodeOffset;
static int G__G__Geom1_200_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoNodeOffset*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoNodeOffset*) (soff+(sizeof(TGeoNodeOffset)*i)))->~G__TTGeoNodeOffset();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoNodeOffset*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoNodeOffset*) (soff))->~G__TTGeoNodeOffset();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoIterator */
static int G__G__Geom1_201_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoIterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoIterator((TGeoVolume*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoIterator((TGeoVolume*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoIterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoIterator* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoIterator(*(TGeoIterator*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TGeoIterator(*(TGeoIterator*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoIterator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TGeoIterator& obj = ((TGeoIterator*) G__getstructoffset())->operator=(*(TGeoIterator*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoIterator*) G__getstructoffset())->operator()());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoIterator*) G__getstructoffset())->Next());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_201_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoIterator*) G__getstructoffset())->GetIndex((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoIterator*) G__getstructoffset())->GetLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TGeoIterator*) G__getstructoffset())->GetNode((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoIterator*) G__getstructoffset())->GetPath(*(TString*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_201_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoIterator*) G__getstructoffset())->GetType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoIterator*) G__getstructoffset())->Reset((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoIterator*) G__getstructoffset())->Reset();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoIterator*) G__getstructoffset())->SetUserPlugin((TGeoIteratorPlugin*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoIterator*) G__getstructoffset())->SetPluginAutoexec((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoIterator*) G__getstructoffset())->SetType((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoIterator*) G__getstructoffset())->SetTopName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoIterator*) G__getstructoffset())->Skip();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoIterator::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoIterator::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoIterator::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoIterator::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_201_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoIterator*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoIterator*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoIterator*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoIterator::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoIterator::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoIterator::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_201_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoIterator::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoIterator G__TTGeoIterator;
static int G__G__Geom1_201_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoIterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoIterator*) (soff+(sizeof(TGeoIterator)*i)))->~G__TTGeoIterator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoIterator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoIterator*) (soff))->~G__TTGeoIterator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoIteratorPlugin */
static int G__G__Geom1_202_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoIteratorPlugin*) G__getstructoffset())->ProcessNode();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoIteratorPlugin*) G__getstructoffset())->SetIterator((TGeoIterator*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoIteratorPlugin::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoIteratorPlugin::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoIteratorPlugin::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoIteratorPlugin::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoIteratorPlugin*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoIteratorPlugin::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoIteratorPlugin::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoIteratorPlugin::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_202_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoIteratorPlugin::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoIteratorPlugin G__TTGeoIteratorPlugin;
static int G__G__Geom1_202_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[] (TGeoIteratorPlugin*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoIteratorPlugin*) (soff+(sizeof(TGeoIteratorPlugin)*i)))->~G__TTGeoIteratorPlugin();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoIteratorPlugin*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoIteratorPlugin*) (soff))->~G__TTGeoIteratorPlugin();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoPara */
static int G__G__Geom1_204_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPara* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoPara[n];
     } else {
       p = new((void*) gvp) TGeoPara[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoPara;
     } else {
       p = new((void*) gvp) TGeoPara;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPara* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoPara(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
   } else {
     p = new((void*) gvp) TGeoPara(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPara* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoPara(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   } else {
     p = new((void*) gvp) TGeoPara(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPara* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoPara((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoPara((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPara*) G__getstructoffset())->GetX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPara*) G__getstructoffset())->GetY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPara*) G__getstructoffset())->GetZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPara*) G__getstructoffset())->GetAlpha());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPara*) G__getstructoffset())->GetTheta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPara*) G__getstructoffset())->GetPhi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPara*) G__getstructoffset())->GetTxy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPara*) G__getstructoffset())->GetTxz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPara*) G__getstructoffset())->GetTyz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoPara::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPara::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoPara::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoPara::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPara*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPara::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPara::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPara::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_204_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPara::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_204_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoPara* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoPara(*(TGeoPara*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoPara G__TTGeoPara;
static int G__G__Geom1_204_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoPara*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoPara*) (soff+(sizeof(TGeoPara)*i)))->~G__TTGeoPara();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoPara*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoPara*) (soff))->~G__TTGeoPara();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_204_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPara* dest = (TGeoPara*) G__getstructoffset();
   *dest = *(TGeoPara*) libp->para[0].ref;
   const TGeoPara& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoTube */
static int G__G__Geom1_205_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTube* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTube[n];
     } else {
       p = new((void*) gvp) TGeoTube[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTube;
     } else {
       p = new((void*) gvp) TGeoTube;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTube* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTube(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) TGeoTube(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTube* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTube(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
   } else {
     p = new((void*) gvp) TGeoTube(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTube* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTube((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoTube((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoTube::Capacity((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoTube::ComputeNormalS((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoTube::DistFromInsideS((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoTube::DistFromOutsideS((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoTube::DistToTube((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTube*) G__getstructoffset())->GetRmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTube*) G__getstructoffset())->GetRmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTube*) G__getstructoffset())->GetDz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoTube*) G__getstructoffset())->HasRmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letdouble(result7, 100, (double) TGeoTube::SafetyS((Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Int_t) G__int(libp->para[5])));
      break;
   case 5:
      G__letdouble(result7, 100, (double) TGeoTube::SafetyS((Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTube*) G__getstructoffset())->SetTubeDimensions((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoTube::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTube::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoTube::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoTube::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTube*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTube::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTube::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTube::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_205_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTube::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_205_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoTube* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoTube(*(TGeoTube*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoTube G__TTGeoTube;
static int G__G__Geom1_205_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoTube*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoTube*) (soff+(sizeof(TGeoTube)*i)))->~G__TTGeoTube();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoTube*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoTube*) (soff))->~G__TTGeoTube();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_205_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTube* dest = (TGeoTube*) G__getstructoffset();
   *dest = *(TGeoTube*) libp->para[0].ref;
   const TGeoTube& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoTubeSeg */
static int G__G__Geom1_206_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTubeSeg* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTubeSeg[n];
     } else {
       p = new((void*) gvp) TGeoTubeSeg[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTubeSeg;
     } else {
       p = new((void*) gvp) TGeoTubeSeg;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTubeSeg* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTubeSeg(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   } else {
     p = new((void*) gvp) TGeoTubeSeg(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTubeSeg* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTubeSeg(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
   } else {
     p = new((void*) gvp) TGeoTubeSeg(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTubeSeg* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTubeSeg((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoTubeSeg((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoTubeSeg::Capacity((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoTubeSeg::ComputeNormalS(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoTubeSeg::DistFromInsideS(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoTubeSeg::DistFromOutsideS(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTubeSeg*) G__getstructoffset())->GetPhi1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTubeSeg*) G__getstructoffset())->GetPhi2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      G__letdouble(result7, 100, (double) TGeoTubeSeg::SafetyS(
(Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Int_t) G__int(libp->para[7])));
      break;
   case 7:
      G__letdouble(result7, 100, (double) TGeoTubeSeg::SafetyS(
(Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTubeSeg*) G__getstructoffset())->SetTubsDimensions((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoTubeSeg::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTubeSeg::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoTubeSeg::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoTubeSeg::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTubeSeg*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTubeSeg::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTubeSeg::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTubeSeg::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_206_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTubeSeg::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_206_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoTubeSeg* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoTubeSeg(*(TGeoTubeSeg*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoTubeSeg G__TTGeoTubeSeg;
static int G__G__Geom1_206_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[] (TGeoTubeSeg*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoTubeSeg*) (soff+(sizeof(TGeoTubeSeg)*i)))->~G__TTGeoTubeSeg();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoTubeSeg*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoTubeSeg*) (soff))->~G__TTGeoTubeSeg();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_206_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTubeSeg* dest = (TGeoTubeSeg*) G__getstructoffset();
   *dest = *(TGeoTubeSeg*) libp->para[0].ref;
   const TGeoTubeSeg& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoCtub */
static int G__G__Geom1_207_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCtub* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoCtub[n];
     } else {
       p = new((void*) gvp) TGeoCtub[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoCtub;
     } else {
       p = new((void*) gvp) TGeoCtub;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCtub* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 11
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoCtub(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   } else {
     p = new((void*) gvp) TGeoCtub(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCtub* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 12
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoCtub(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11]));
   } else {
     p = new((void*) gvp) TGeoCtub(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCtub* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoCtub((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoCtub((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoCtub*) G__getstructoffset())->GetNlow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoCtub*) G__getstructoffset())->GetNhigh());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoCtub*) G__getstructoffset())->GetZcoord((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoCtub*) G__getstructoffset())->SetCtubDimensions(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoCtub::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoCtub::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoCtub::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoCtub::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoCtub*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoCtub::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoCtub::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoCtub::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_207_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoCtub::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_207_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoCtub* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoCtub(*(TGeoCtub*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoCtub G__TTGeoCtub;
static int G__G__Geom1_207_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[] (TGeoCtub*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoCtub*) (soff+(sizeof(TGeoCtub)*i)))->~G__TTGeoCtub();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoCtub*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoCtub*) (soff))->~G__TTGeoCtub();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_207_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCtub* dest = (TGeoCtub*) G__getstructoffset();
   *dest = *(TGeoCtub*) libp->para[0].ref;
   const TGeoCtub& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoTorus */
static int G__G__Geom1_208_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTorus*) G__getstructoffset())->Daxis((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTorus*) G__getstructoffset())->DDaxis((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTorus*) G__getstructoffset())->DDDaxis((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTorus*) G__getstructoffset())->ToBoundary((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoTorus*) G__getstructoffset())->SolveCubic((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoTorus*) G__getstructoffset())->SolveQuartic((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t*) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTorus* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTorus[n];
     } else {
       p = new((void*) gvp) TGeoTorus[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTorus;
     } else {
       p = new((void*) gvp) TGeoTorus;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTorus* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTorus(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TGeoTorus(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTorus(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TGeoTorus(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTorus(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TGeoTorus(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTorus* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTorus(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TGeoTorus(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTorus(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TGeoTorus(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTorus(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TGeoTorus(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTorus* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTorus((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoTorus((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTorus*) G__getstructoffset())->GetR());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTorus*) G__getstructoffset())->GetRmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTorus*) G__getstructoffset())->GetRmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTorus*) G__getstructoffset())->GetPhi1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTorus*) G__getstructoffset())->GetDphi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTorus*) G__getstructoffset())->SetTorusDimensions((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoTorus::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTorus::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoTorus::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoTorus::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTorus*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTorus::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTorus::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTorus::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_208_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTorus::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_208_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoTorus* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoTorus(*(TGeoTorus*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoTorus G__TTGeoTorus;
static int G__G__Geom1_208_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoTorus*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoTorus*) (soff+(sizeof(TGeoTorus)*i)))->~G__TTGeoTorus();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoTorus*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoTorus*) (soff))->~G__TTGeoTorus();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_208_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTorus* dest = (TGeoTorus*) G__getstructoffset();
   *dest = *(TGeoTorus*) libp->para[0].ref;
   const TGeoTorus& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoSphere */
static int G__G__Geom1_209_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoSphere* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSphere[n];
     } else {
       p = new((void*) gvp) TGeoSphere[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSphere;
     } else {
       p = new((void*) gvp) TGeoSphere;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoSphere* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSphere(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TGeoSphere(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSphere(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TGeoSphere(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSphere(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TGeoSphere(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSphere(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TGeoSphere(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSphere((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoSphere((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoSphere* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSphere(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     } else {
       p = new((void*) gvp) TGeoSphere(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSphere(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TGeoSphere(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSphere(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TGeoSphere(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSphere(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TGeoSphere(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSphere(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TGeoSphere(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoSphere* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSphere((Double_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoSphere((Double_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoSphere((Double_t*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TGeoSphere((Double_t*) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letdouble(result7, 100, (double) ((const TGeoSphere*) G__getstructoffset())->DistToSphere((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letdouble(result7, 100, (double) ((const TGeoSphere*) G__getstructoffset())->DistToSphere((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const TGeoSphere*) G__getstructoffset())->DistToSphere((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoSphere*) G__getstructoffset())->GetNumberOfDivisions());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoSphere*) G__getstructoffset())->GetNz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoSphere*) G__getstructoffset())->GetRmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoSphere*) G__getstructoffset())->GetRmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoSphere*) G__getstructoffset())->GetTheta1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoSphere*) G__getstructoffset())->GetTheta2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoSphere*) G__getstructoffset())->GetPhi1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoSphere*) G__getstructoffset())->GetPhi2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoSphere*) G__getstructoffset())->IsOnBoundary((Double_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) ((const TGeoSphere*) G__getstructoffset())->IsPointInside((Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) ((const TGeoSphere*) G__getstructoffset())->IsPointInside((Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) ((const TGeoSphere*) G__getstructoffset())->IsPointInside((Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((const TGeoSphere*) G__getstructoffset())->IsPointInside((Double_t*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoSphere*) G__getstructoffset())->SetSphDimensions((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoSphere*) G__getstructoffset())->SetNumberOfDivisions((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoSphere::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoSphere::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoSphere::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoSphere::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoSphere*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoSphere::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoSphere::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoSphere::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_209_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoSphere::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_209_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoSphere* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoSphere(*(TGeoSphere*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoSphere G__TTGeoSphere;
static int G__G__Geom1_209_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[] (TGeoSphere*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoSphere*) (soff+(sizeof(TGeoSphere)*i)))->~G__TTGeoSphere();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoSphere*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoSphere*) (soff))->~G__TTGeoSphere();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_209_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoSphere* dest = (TGeoSphere*) G__getstructoffset();
   *dest = *(TGeoSphere*) libp->para[0].ref;
   const TGeoSphere& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoEltu */
static int G__G__Geom1_210_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoEltu* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoEltu[n];
     } else {
       p = new((void*) gvp) TGeoEltu[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoEltu;
     } else {
       p = new((void*) gvp) TGeoEltu;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoEltu* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoEltu(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) TGeoEltu(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoEltu* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoEltu(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
   } else {
     p = new((void*) gvp) TGeoEltu(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoEltu* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoEltu((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoEltu((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoEltu*) G__getstructoffset())->GetA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoEltu*) G__getstructoffset())->GetB());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoEltu*) G__getstructoffset())->SetEltuDimensions((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoEltu::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoEltu::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoEltu::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoEltu::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoEltu*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoEltu::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoEltu::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoEltu::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_210_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoEltu::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_210_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoEltu* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoEltu(*(TGeoEltu*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoEltu G__TTGeoEltu;
static int G__G__Geom1_210_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[] (TGeoEltu*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoEltu*) (soff+(sizeof(TGeoEltu)*i)))->~G__TTGeoEltu();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoEltu*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoEltu*) (soff))->~G__TTGeoEltu();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_210_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoEltu* dest = (TGeoEltu*) G__getstructoffset();
   *dest = *(TGeoEltu*) libp->para[0].ref;
   const TGeoEltu& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoHype */
static int G__G__Geom1_211_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoHype* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoHype[n];
     } else {
       p = new((void*) gvp) TGeoHype[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoHype;
     } else {
       p = new((void*) gvp) TGeoHype;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoHype* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoHype(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   } else {
     p = new((void*) gvp) TGeoHype(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoHype* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoHype(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
   } else {
     p = new((void*) gvp) TGeoHype(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoHype* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoHype((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoHype((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoHype*) G__getstructoffset())->DistToHype((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoHype*) G__getstructoffset())->GetStIn());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoHype*) G__getstructoffset())->GetStOut());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoHype*) G__getstructoffset())->HasInner());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoHype*) G__getstructoffset())->RadiusHypeSq((Double_t) G__double(libp->para[0]), (Bool_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoHype*) G__getstructoffset())->ZHypeSq((Double_t) G__double(libp->para[0]), (Bool_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoHype*) G__getstructoffset())->SafetyToHype((Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHype*) G__getstructoffset())->SetHypeDimensions((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoHype::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoHype::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoHype::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoHype::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHype*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoHype::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoHype::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoHype::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_211_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoHype::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_211_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoHype* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoHype(*(TGeoHype*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoHype G__TTGeoHype;
static int G__G__Geom1_211_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoHype*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoHype*) (soff+(sizeof(TGeoHype)*i)))->~G__TTGeoHype();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoHype*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoHype*) (soff))->~G__TTGeoHype();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_211_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoHype* dest = (TGeoHype*) G__getstructoffset();
   *dest = *(TGeoHype*) libp->para[0].ref;
   const TGeoHype& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoCone */
static int G__G__Geom1_212_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCone* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoCone[n];
     } else {
       p = new((void*) gvp) TGeoCone[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoCone;
     } else {
       p = new((void*) gvp) TGeoCone;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCone* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoCone(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   } else {
     p = new((void*) gvp) TGeoCone(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCone* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoCone(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
   } else {
     p = new((void*) gvp) TGeoCone(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCone* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoCone((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoCone((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoCone::Capacity((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoCone::ComputeNormalS(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoCone::DistToCone(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5])
, *(Double_t*) G__Doubleref(&libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoCone::DistFromInsideS(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoCone::DistFromOutsideS(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoCone*) G__getstructoffset())->GetDz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoCone*) G__getstructoffset())->GetRmin1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoCone*) G__getstructoffset())->GetRmax1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoCone*) G__getstructoffset())->GetRmin2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoCone*) G__getstructoffset())->GetRmax2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      G__letdouble(result7, 100, (double) TGeoCone::SafetyS(
(Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Int_t) G__int(libp->para[7])));
      break;
   case 7:
      G__letdouble(result7, 100, (double) TGeoCone::SafetyS(
(Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoCone*) G__getstructoffset())->SetConeDimensions((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoCone::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoCone::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoCone::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoCone::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoCone*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoCone::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoCone::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoCone::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_212_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoCone::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_212_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoCone* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoCone(*(TGeoCone*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoCone G__TTGeoCone;
static int G__G__Geom1_212_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoCone*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoCone*) (soff+(sizeof(TGeoCone)*i)))->~G__TTGeoCone();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoCone*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoCone*) (soff))->~G__TTGeoCone();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_212_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCone* dest = (TGeoCone*) G__getstructoffset();
   *dest = *(TGeoCone*) libp->para[0].ref;
   const TGeoCone& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoConeSeg */
static int G__G__Geom1_213_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoConeSeg* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoConeSeg[n];
     } else {
       p = new((void*) gvp) TGeoConeSeg[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoConeSeg;
     } else {
       p = new((void*) gvp) TGeoConeSeg;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoConeSeg* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 7
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoConeSeg(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   } else {
     p = new((void*) gvp) TGeoConeSeg(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoConeSeg* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoConeSeg(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   } else {
     p = new((void*) gvp) TGeoConeSeg(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoConeSeg* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoConeSeg((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoConeSeg((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoConeSeg::Capacity(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoConeSeg::ComputeNormalS(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoConeSeg::DistToCons(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoConeSeg::DistFromInsideS(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
, (Double_t) G__double(libp->para[12]), (Double_t) G__double(libp->para[13])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) TGeoConeSeg::DistFromOutsideS(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
, (Double_t) G__double(libp->para[12]), (Double_t) G__double(libp->para[13])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoConeSeg*) G__getstructoffset())->GetPhi1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoConeSeg*) G__getstructoffset())->GetPhi2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 10:
      G__letdouble(result7, 100, (double) TGeoConeSeg::SafetyS(
(Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Int_t) G__int(libp->para[9])));
      break;
   case 9:
      G__letdouble(result7, 100, (double) TGeoConeSeg::SafetyS(
(Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoConeSeg*) G__getstructoffset())->SetConsDimensions(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoConeSeg::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoConeSeg::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoConeSeg::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoConeSeg::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoConeSeg*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoConeSeg::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoConeSeg::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoConeSeg::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_213_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoConeSeg::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_213_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoConeSeg* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoConeSeg(*(TGeoConeSeg*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoConeSeg G__TTGeoConeSeg;
static int G__G__Geom1_213_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoConeSeg*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoConeSeg*) (soff+(sizeof(TGeoConeSeg)*i)))->~G__TTGeoConeSeg();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoConeSeg*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoConeSeg*) (soff))->~G__TTGeoConeSeg();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_213_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoConeSeg* dest = (TGeoConeSeg*) G__getstructoffset();
   *dest = *(TGeoConeSeg*) libp->para[0].ref;
   const TGeoConeSeg& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoPcon */
static int G__G__Geom1_214_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPcon* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoPcon[n];
     } else {
       p = new((void*) gvp) TGeoPcon[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoPcon;
     } else {
       p = new((void*) gvp) TGeoPcon;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPcon* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoPcon(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGeoPcon(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPcon* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoPcon(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TGeoPcon(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPcon* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoPcon((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoPcon((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPcon*) G__getstructoffset())->DefineSection((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPcon*) G__getstructoffset())->DistToSegZ(
(Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPcon*) G__getstructoffset())->GetPhi1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPcon*) G__getstructoffset())->GetDphi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoPcon*) G__getstructoffset())->GetNz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoPcon*) G__getstructoffset())->GetNsegments());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoPcon*) G__getstructoffset())->GetRmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPcon*) G__getstructoffset())->GetRmin((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoPcon*) G__getstructoffset())->GetRmax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPcon*) G__getstructoffset())->GetRmax((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoPcon*) G__getstructoffset())->GetZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPcon*) G__getstructoffset())->GetZ((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TGeoPcon*) G__getstructoffset())->Phi1();
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TGeoPcon*) G__getstructoffset())->Dphi();
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TGeoPcon*) G__getstructoffset())->Rmin((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TGeoPcon*) G__getstructoffset())->Rmax((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TGeoPcon*) G__getstructoffset())->Z((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letdouble(result7, 100, (double) ((const TGeoPcon*) G__getstructoffset())->SafetyToSegment((Double_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((const TGeoPcon*) G__getstructoffset())->SafetyToSegment((Double_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((const TGeoPcon*) G__getstructoffset())->SafetyToSegment((Double_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoPcon::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPcon::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoPcon::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoPcon::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPcon*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPcon::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPcon::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPcon::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_214_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPcon::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoPcon G__TTGeoPcon;
static int G__G__Geom1_214_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoPcon*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoPcon*) (soff+(sizeof(TGeoPcon)*i)))->~G__TTGeoPcon();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoPcon*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoPcon*) (soff))->~G__TTGeoPcon();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoPgon */
static int G__G__Geom1_215_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPgon* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoPgon[n];
     } else {
       p = new((void*) gvp) TGeoPgon[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoPgon;
     } else {
       p = new((void*) gvp) TGeoPgon;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPgon* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoPgon(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TGeoPgon(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPgon* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoPgon(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TGeoPgon(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPgon* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoPgon((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoPgon((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoPgon*) G__getstructoffset())->GetNedges());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      G__letdouble(result7, 100, (double) ((const TGeoPgon*) G__getstructoffset())->SafetyToSegment((Double_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   case 5:
      G__letdouble(result7, 100, (double) ((const TGeoPgon*) G__getstructoffset())->SafetyToSegment((Double_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPgon*) G__getstructoffset())->SetNedges((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoPgon::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPgon::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoPgon::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoPgon::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPgon*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPgon::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPgon::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPgon::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_215_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPgon::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_215_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoPgon* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoPgon(*(TGeoPgon*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoPgon G__TTGeoPgon;
static int G__G__Geom1_215_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoPgon*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoPgon*) (soff+(sizeof(TGeoPgon)*i)))->~G__TTGeoPgon();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoPgon*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoPgon*) (soff))->~G__TTGeoPgon();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoArb8 */
static int G__G__Geom1_216_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoArb8* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoArb8[n];
     } else {
       p = new((void*) gvp) TGeoArb8[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoArb8;
     } else {
       p = new((void*) gvp) TGeoArb8;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoArb8* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoArb8((Double_t) G__double(libp->para[0]), (Double_t*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoArb8((Double_t) G__double(libp->para[0]), (Double_t*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoArb8((Double_t) G__double(libp->para[0]));
     } else {
       p = new((void*) gvp) TGeoArb8((Double_t) G__double(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoArb8* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoArb8(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGeoArb8(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoArb8((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoArb8((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoArb8*) G__getstructoffset())->ComputeTwist();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoArb8*) G__getstructoffset())->DistToPlane((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoArb8*) G__getstructoffset())->GetClosestEdge((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoArb8*) G__getstructoffset())->GetDz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoArb8::GetPlaneNormal((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGeoArb8*) G__getstructoffset())->GetVertices());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoArb8*) G__getstructoffset())->GetTwist((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGeoArb8::IsSamePoint((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TGeoArb8::InsidePolygon((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoArb8*) G__getstructoffset())->IsTwisted());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoArb8*) G__getstructoffset())->SafetyToFace((Double_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoArb8*) G__getstructoffset())->SetPlaneVertices((Double_t) G__double(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoArb8*) G__getstructoffset())->SetVertex((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoArb8*) G__getstructoffset())->SetDz((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoArb8::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoArb8::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoArb8::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoArb8::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoArb8*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoArb8::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoArb8::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoArb8::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_216_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoArb8::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoArb8 G__TTGeoArb8;
static int G__G__Geom1_216_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[] (TGeoArb8*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoArb8*) (soff+(sizeof(TGeoArb8)*i)))->~G__TTGeoArb8();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoArb8*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoArb8*) (soff))->~G__TTGeoArb8();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoTrap */
static int G__G__Geom1_218_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTrap* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTrap[n];
     } else {
       p = new((void*) gvp) TGeoTrap[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTrap;
     } else {
       p = new((void*) gvp) TGeoTrap;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTrap* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTrap(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) TGeoTrap(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTrap* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 11
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTrap(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   } else {
     p = new((void*) gvp) TGeoTrap(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTrap* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 12
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTrap(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11]));
   } else {
     p = new((void*) gvp) TGeoTrap(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrap*) G__getstructoffset())->GetTheta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrap*) G__getstructoffset())->GetPhi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrap*) G__getstructoffset())->GetH1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrap*) G__getstructoffset())->GetBl1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrap*) G__getstructoffset())->GetTl1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrap*) G__getstructoffset())->GetAlpha1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrap*) G__getstructoffset())->GetH2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrap*) G__getstructoffset())->GetBl2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrap*) G__getstructoffset())->GetTl2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrap*) G__getstructoffset())->GetAlpha2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoTrap::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTrap::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoTrap::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoTrap::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTrap*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTrap::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTrap::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTrap::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_218_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTrap::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_218_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoTrap* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoTrap(*(TGeoTrap*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoTrap G__TTGeoTrap;
static int G__G__Geom1_218_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoTrap*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoTrap*) (soff+(sizeof(TGeoTrap)*i)))->~G__TTGeoTrap();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoTrap*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoTrap*) (soff))->~G__TTGeoTrap();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoGtra */
static int G__G__Geom1_219_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoGtra* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoGtra[n];
     } else {
       p = new((void*) gvp) TGeoGtra[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoGtra;
     } else {
       p = new((void*) gvp) TGeoGtra;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_219_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoGtra* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 12
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoGtra(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11]));
   } else {
     p = new((void*) gvp) TGeoGtra(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_219_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoGtra* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 13
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoGtra(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
, (Double_t) G__double(libp->para[12]));
   } else {
     p = new((void*) gvp) TGeoGtra(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
, (Double_t) G__double(libp->para[12]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_219_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoGtra*) G__getstructoffset())->GetTwistAngle());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_219_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoGtra::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_219_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoGtra::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_219_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoGtra::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_219_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoGtra::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_219_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoGtra*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_219_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoGtra::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_219_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoGtra::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_219_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoGtra::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_219_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoGtra::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_219_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoGtra* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoGtra(*(TGeoGtra*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoGtra G__TTGeoGtra;
static int G__G__Geom1_219_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[] (TGeoGtra*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoGtra*) (soff+(sizeof(TGeoGtra)*i)))->~G__TTGeoGtra();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoGtra*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoGtra*) (soff))->~G__TTGeoGtra();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoTrd1 */
static int G__G__Geom1_220_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTrd1* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTrd1[n];
     } else {
       p = new((void*) gvp) TGeoTrd1[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTrd1;
     } else {
       p = new((void*) gvp) TGeoTrd1;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTrd1* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTrd1(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
   } else {
     p = new((void*) gvp) TGeoTrd1(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTrd1* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTrd1(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   } else {
     p = new((void*) gvp) TGeoTrd1(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTrd1* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTrd1((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoTrd1((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrd1*) G__getstructoffset())->GetDx1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrd1*) G__getstructoffset())->GetDx2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrd1*) G__getstructoffset())->GetDy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrd1*) G__getstructoffset())->GetDz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoTrd1*) G__getstructoffset())->GetVisibleCorner((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoTrd1*) G__getstructoffset())->GetOppositeCorner((Double_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoTrd1*) G__getstructoffset())->SetVertex((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoTrd1::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTrd1::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoTrd1::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoTrd1::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTrd1*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTrd1::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTrd1::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTrd1::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_220_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTrd1::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_220_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoTrd1* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoTrd1(*(TGeoTrd1*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoTrd1 G__TTGeoTrd1;
static int G__G__Geom1_220_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoTrd1*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoTrd1*) (soff+(sizeof(TGeoTrd1)*i)))->~G__TTGeoTrd1();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoTrd1*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoTrd1*) (soff))->~G__TTGeoTrd1();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_220_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTrd1* dest = (TGeoTrd1*) G__getstructoffset();
   *dest = *(TGeoTrd1*) libp->para[0].ref;
   const TGeoTrd1& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoTrd2 */
static int G__G__Geom1_221_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTrd2* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTrd2[n];
     } else {
       p = new((void*) gvp) TGeoTrd2[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoTrd2;
     } else {
       p = new((void*) gvp) TGeoTrd2;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTrd2* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTrd2(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   } else {
     p = new((void*) gvp) TGeoTrd2(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTrd2* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTrd2(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
   } else {
     p = new((void*) gvp) TGeoTrd2(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTrd2* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoTrd2((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoTrd2((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrd2*) G__getstructoffset())->GetDx1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrd2*) G__getstructoffset())->GetDx2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrd2*) G__getstructoffset())->GetDy1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrd2*) G__getstructoffset())->GetDy2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoTrd2*) G__getstructoffset())->GetDz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoTrd2*) G__getstructoffset())->GetVisibleCorner((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoTrd2*) G__getstructoffset())->GetOppositeCorner((Double_t*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoTrd2*) G__getstructoffset())->SetVertex((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoTrd2::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTrd2::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoTrd2::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoTrd2::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoTrd2*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTrd2::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTrd2::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoTrd2::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_221_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoTrd2::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_221_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoTrd2* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoTrd2(*(TGeoTrd2*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoTrd2 G__TTGeoTrd2;
static int G__G__Geom1_221_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[] (TGeoTrd2*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoTrd2*) (soff+(sizeof(TGeoTrd2)*i)))->~G__TTGeoTrd2();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoTrd2*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoTrd2*) (soff))->~G__TTGeoTrd2();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_221_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoTrd2* dest = (TGeoTrd2*) G__getstructoffset();
   *dest = *(TGeoTrd2*) libp->para[0].ref;
   const TGeoTrd2& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoNavigator */
static int G__G__Geom1_224_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoNavigator* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoNavigator[n];
     } else {
       p = new((void*) gvp) TGeoNavigator[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoNavigator;
     } else {
       p = new((void*) gvp) TGeoNavigator;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNavigator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoNavigator* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoNavigator((TGeoManager*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoNavigator((TGeoManager*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNavigator));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGeoNavigator*) G__getstructoffset())->BuildCache((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoNavigator*) G__getstructoffset())->BuildCache((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoNavigator*) G__getstructoffset())->BuildCache();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 103, (long) ((TGeoNavigator*) G__getstructoffset())->cd((const char*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((TGeoNavigator*) G__getstructoffset())->cd());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNavigator*) G__getstructoffset())->CheckPath((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNavigator*) G__getstructoffset())->CdNode((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNavigator*) G__getstructoffset())->CdDown((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNavigator*) G__getstructoffset())->CdUp();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNavigator*) G__getstructoffset())->CdTop();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNavigator*) G__getstructoffset())->CdNext();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNavigator*) G__getstructoffset())->GetBranchNames((Int_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNavigator*) G__getstructoffset())->GetBranchNumbers((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__Geom1_224_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNavigator*) G__getstructoffset())->GetBranchOnlys((Int_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoNavigator*) G__getstructoffset())->GetNmany());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->CrossBoundaryAndLocate((Bool_t) G__int(libp->para[0]), (TGeoNode*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->FindNextBoundary((Double_t) G__double(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->FindNextBoundary((Double_t) G__double(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->FindNextBoundary((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->FindNextBoundary());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->FindNextDaughterBoundary((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2]), (Bool_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->FindNextDaughterBoundary((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, *(Int_t*) G__Intref(&libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->FindNextBoundaryAndStep((Double_t) G__double(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->FindNextBoundaryAndStep((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->FindNextBoundaryAndStep());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->FindNode((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->FindNode());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->FindNode((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 68, (long) ((TGeoNavigator*) G__getstructoffset())->FindNormal((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 68, (long) ((TGeoNavigator*) G__getstructoffset())->FindNormal());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGeoNavigator*) G__getstructoffset())->FindNormalFast());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->InitTrack((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->InitTrack((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNavigator*) G__getstructoffset())->ResetState();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNavigator*) G__getstructoffset())->ResetAll();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((TGeoNavigator*) G__getstructoffset())->Safety((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((TGeoNavigator*) G__getstructoffset())->Safety());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->SearchNode((Bool_t) G__int(libp->para[0]), (TGeoNode*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->SearchNode((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->SearchNode());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->Step((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->Step((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->Step());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoNavigator*) G__getstructoffset())->GetLastPoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoNavigator*) G__getstructoffset())->GetVirtualLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGeoNavigator*) G__getstructoffset())->GotoSafeLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoNavigator*) G__getstructoffset())->GetSafeLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoNavigator*) G__getstructoffset())->GetSafeDistance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoNavigator*) G__getstructoffset())->GetLastSafety());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoNavigator*) G__getstructoffset())->GetStep());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNavigator*) G__getstructoffset())->InspectState();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNavigator*) G__getstructoffset())->IsSafeStep((Double_t) G__double(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) ((TGeoNavigator*) G__getstructoffset())->IsSameLocation((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) ((TGeoNavigator*) G__getstructoffset())->IsSameLocation((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNavigator*) G__getstructoffset())->IsSameLocation());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNavigator*) G__getstructoffset())->IsSamePoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNavigator*) G__getstructoffset())->IsStartSafe());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoNavigator*) G__getstructoffset())->SetStartSafe((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoNavigator*) G__getstructoffset())->SetStartSafe();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNavigator*) G__getstructoffset())->SetStep((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNavigator*) G__getstructoffset())->IsCheckingOverlaps());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNavigator*) G__getstructoffset())->IsCurrentOverlapping());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNavigator*) G__getstructoffset())->IsEntering());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNavigator*) G__getstructoffset())->IsExiting());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNavigator*) G__getstructoffset())->IsStepEntering());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNavigator*) G__getstructoffset())->IsStepExiting());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNavigator*) G__getstructoffset())->IsOutside());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNavigator*) G__getstructoffset())->IsOnBoundary());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoNavigator*) G__getstructoffset())->IsNullStep());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoNavigator*) G__getstructoffset())->SetCheckingOverlaps((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoNavigator*) G__getstructoffset())->SetCheckingOverlaps();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoNavigator*) G__getstructoffset())->SetOutside((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoNavigator*) G__getstructoffset())->SetOutside();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNavigator*) G__getstructoffset())->DoBackupState();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNavigator*) G__getstructoffset())->DoRestoreState();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoNavigator*) G__getstructoffset())->GetNodeId());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_224_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TGeoNavigator*) G__getstructoffset())->GetMother((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TGeoNavigator*) G__getstructoffset())->GetMother());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TGeoNavigator*) G__getstructoffset())->GetMotherMatrix((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TGeoNavigator*) G__getstructoffset())->GetMotherMatrix());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoNavigator*) G__getstructoffset())->GetHMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_224_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoNavigator*) G__getstructoffset())->GetCurrentNodeId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoNavigator*) G__getstructoffset())->GetCurrentPoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoNavigator*) G__getstructoffset())->GetCurrentDirection());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_224_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoNavigator*) G__getstructoffset())->GetCldirChecked());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoNavigator*) G__getstructoffset())->GetCldir());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoNavigator*) G__getstructoffset())->GetNormal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoNavigator*) G__getstructoffset())->GetLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGeoNavigator*) G__getstructoffset())->GetPath());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoNavigator*) G__getstructoffset())->GetStackLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNavigator*) G__getstructoffset())->SetCurrentPoint((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNavigator*) G__getstructoffset())->SetCurrentPoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNavigator*) G__getstructoffset())->SetLastPoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNavigator*) G__getstructoffset())->SetCurrentDirection((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNavigator*) G__getstructoffset())->SetCurrentDirection((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNavigator*) G__getstructoffset())->SetCldirChecked((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNavigator*) G__getstructoffset())->LocalToMaster((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNavigator*) G__getstructoffset())->LocalToMasterVect((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNavigator*) G__getstructoffset())->LocalToMasterBomb((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNavigator*) G__getstructoffset())->MasterToLocal((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNavigator*) G__getstructoffset())->MasterToLocalVect((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNavigator*) G__getstructoffset())->MasterToLocalBomb((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNavigator*) G__getstructoffset())->MasterToTop((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoNavigator*) G__getstructoffset())->TopToMaster((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_224_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TGeoNavigator*) G__getstructoffset())->PushPath((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TGeoNavigator*) G__getstructoffset())->PushPath());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGeoNavigator*) G__getstructoffset())->PopPath());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGeoNavigator*) G__getstructoffset())->PopPath((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TGeoNavigator*) G__getstructoffset())->PushPoint((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TGeoNavigator*) G__getstructoffset())->PushPoint());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGeoNavigator*) G__getstructoffset())->PopPoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGeoNavigator*) G__getstructoffset())->PopPoint((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoNavigator*) G__getstructoffset())->PopDummy((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoNavigator*) G__getstructoffset())->PopDummy();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoNavigator::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoNavigator::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoNavigator::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoNavigator::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoNavigator*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoNavigator::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoNavigator::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoNavigator::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_224_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoNavigator::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoNavigator G__TTGeoNavigator;
static int G__G__Geom1_224_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoNavigator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoNavigator*) (soff+(sizeof(TGeoNavigator)*i)))->~G__TTGeoNavigator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoNavigator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoNavigator*) (soff))->~G__TTGeoNavigator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVirtualGeoTrack */
static int G__G__Geom1_225_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TVirtualGeoTrack*) G__getstructoffset())->AddDaughter((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TObject*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TVirtualGeoTrack*) G__getstructoffset())->AddDaughter((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualGeoTrack*) G__getstructoffset())->AddDaughter((TVirtualGeoTrack*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoTrack*) G__getstructoffset())->AddPoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualGeoTrack*) G__getstructoffset())->FindTrackWithId((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualGeoTrack*) G__getstructoffset())->GetId());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualGeoTrack*) G__getstructoffset())->GetDaughterId((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TVirtualGeoTrack*) G__getstructoffset())->GetDaughter((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_225_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualGeoTrack*) G__getstructoffset())->GetNdaughters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualGeoTrack*) G__getstructoffset())->GetNpoints());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualGeoTrack*) G__getstructoffset())->GetParentId());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_225_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualGeoTrack*) G__getstructoffset())->GetPDG());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualGeoTrack*) G__getstructoffset())->GetLastPoint(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TVirtualGeoTrack*) G__getstructoffset())->GetFirstPoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TVirtualGeoTrack*) G__getstructoffset())->GetLastPoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualGeoTrack*) G__getstructoffset())->GetPoint((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TVirtualGeoTrack*) G__getstructoffset())->GetPoint((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualGeoTrack*) G__getstructoffset())->HasPoints());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualGeoTrack*) G__getstructoffset())->IsInTimeRange());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoTrack*) G__getstructoffset())->PaintCollect((Double_t) G__double(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoTrack*) G__getstructoffset())->PaintCollectTrack((Double_t) G__double(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualGeoTrack*) G__getstructoffset())->PaintTrack((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualGeoTrack*) G__getstructoffset())->PaintTrack();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoTrack*) G__getstructoffset())->ResetTrack();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoTrack*) G__getstructoffset())->SetName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoTrack*) G__getstructoffset())->SetParticle((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoTrack*) G__getstructoffset())->SetParent((TVirtualGeoTrack*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoTrack*) G__getstructoffset())->SetId((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoTrack*) G__getstructoffset())->SetPDG((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualGeoTrack::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualGeoTrack::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVirtualGeoTrack::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualGeoTrack::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoTrack*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualGeoTrack::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualGeoTrack::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualGeoTrack::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_225_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualGeoTrack::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVirtualGeoTrack G__TTVirtualGeoTrack;
static int G__G__Geom1_225_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TVirtualGeoTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVirtualGeoTrack*) (soff+(sizeof(TVirtualGeoTrack)*i)))->~G__TTVirtualGeoTrack();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVirtualGeoTrack*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVirtualGeoTrack*) (soff))->~G__TTVirtualGeoTrack();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoPhysicalNode */
static int G__G__Geom1_226_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPhysicalNode* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoPhysicalNode[n];
     } else {
       p = new((void*) gvp) TGeoPhysicalNode[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoPhysicalNode;
     } else {
       p = new((void*) gvp) TGeoPhysicalNode;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPhysicalNode* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoPhysicalNode((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoPhysicalNode((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGeoPhysicalNode*) G__getstructoffset())->Align((TGeoMatrix*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGeoPhysicalNode*) G__getstructoffset())->Align((TGeoMatrix*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGeoPhysicalNode*) G__getstructoffset())->Align((TGeoMatrix*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoPhysicalNode*) G__getstructoffset())->Align((TGeoMatrix*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoPhysicalNode*) G__getstructoffset())->Align();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TGeoPhysicalNode*) G__getstructoffset())->cd();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoPhysicalNode*) G__getstructoffset())->GetLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TGeoPhysicalNode*) G__getstructoffset())->GetMatrix((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TGeoPhysicalNode*) G__getstructoffset())->GetMatrix());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_226_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TGeoPhysicalNode*) G__getstructoffset())->GetMother((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TGeoPhysicalNode*) G__getstructoffset())->GetMother());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TGeoPhysicalNode*) G__getstructoffset())->GetNode((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TGeoPhysicalNode*) G__getstructoffset())->GetNode());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TGeoPhysicalNode*) G__getstructoffset())->GetShape((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TGeoPhysicalNode*) G__getstructoffset())->GetShape());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TGeoPhysicalNode*) G__getstructoffset())->GetVolume((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TGeoPhysicalNode*) G__getstructoffset())->GetVolume());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoPhysicalNode*) G__getstructoffset())->IsAligned());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoPhysicalNode*) G__getstructoffset())->IsVolAttributes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoPhysicalNode*) G__getstructoffset())->IsVisible());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoPhysicalNode*) G__getstructoffset())->IsVisibleFull());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPhysicalNode*) G__getstructoffset())->Refresh();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPhysicalNode*) G__getstructoffset())->SetMatrixOrig((TGeoMatrix*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoPhysicalNode*) G__getstructoffset())->SetIsVolAtt((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoPhysicalNode*) G__getstructoffset())->SetIsVolAtt();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoPhysicalNode*) G__getstructoffset())->SetVisibility((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoPhysicalNode*) G__getstructoffset())->SetVisibility();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoPhysicalNode*) G__getstructoffset())->SetVisibleFull((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoPhysicalNode*) G__getstructoffset())->SetVisibleFull();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoPhysicalNode::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPhysicalNode::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoPhysicalNode::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoPhysicalNode::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPhysicalNode*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPhysicalNode::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPhysicalNode::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPhysicalNode::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_226_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPhysicalNode::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoPhysicalNode G__TTGeoPhysicalNode;
static int G__G__Geom1_226_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[] (TGeoPhysicalNode*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoPhysicalNode*) (soff+(sizeof(TGeoPhysicalNode)*i)))->~G__TTGeoPhysicalNode();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoPhysicalNode*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoPhysicalNode*) (soff))->~G__TTGeoPhysicalNode();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoPNEntry */
static int G__G__Geom1_227_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPNEntry* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoPNEntry[n];
     } else {
       p = new((void*) gvp) TGeoPNEntry[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoPNEntry;
     } else {
       p = new((void*) gvp) TGeoPNEntry;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPNEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_227_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPNEntry* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoPNEntry((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGeoPNEntry((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPNEntry));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_227_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TGeoPNEntry*) G__getstructoffset())->GetPath());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__Geom1_227_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPNEntry*) G__getstructoffset())->SetMatrix((TGeoHMatrix*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_227_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPNEntry*) G__getstructoffset())->SetPhysicalNode((TGeoPhysicalNode*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_227_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoPNEntry::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_227_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPNEntry::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_227_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoPNEntry::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_227_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoPNEntry::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_227_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPNEntry*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_227_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPNEntry::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_227_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPNEntry::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_227_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPNEntry::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_227_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPNEntry::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoPNEntry G__TTGeoPNEntry;
static int G__G__Geom1_227_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoPNEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoPNEntry*) (soff+(sizeof(TGeoPNEntry)*i)))->~G__TTGeoPNEntry();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoPNEntry*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoPNEntry*) (soff))->~G__TTGeoPNEntry();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVirtualGeoPainter */
static int G__G__Geom1_228_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->AddSize3D((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVirtualGeoPainter*) G__getstructoffset())->AddTrack((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TObject*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TVirtualGeoPainter*) G__getstructoffset())->AddTrackPoint((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TVirtualGeoPainter*) G__getstructoffset())->AddTrackPoint((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->BombTranslation((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TVirtualGeoPainter*) G__getstructoffset())->CheckPoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Option_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TVirtualGeoPainter*) G__getstructoffset())->CheckPoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TVirtualGeoPainter*) G__getstructoffset())->CheckPoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->CheckPoint((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualGeoPainter*) G__getstructoffset())->CheckPoint();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVirtualGeoPainter*) G__getstructoffset())->CheckBoundaryErrors((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->CheckBoundaryErrors((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualGeoPainter*) G__getstructoffset())->CheckBoundaryErrors();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->CheckBoundaryReference((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualGeoPainter*) G__getstructoffset())->CheckBoundaryReference();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TVirtualGeoPainter*) G__getstructoffset())->CheckGeometryFull((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TVirtualGeoPainter*) G__getstructoffset())->CheckGeometryFull((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TVirtualGeoPainter*) G__getstructoffset())->CheckGeometryFull((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->CheckGeometryFull((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualGeoPainter*) G__getstructoffset())->CheckGeometryFull();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TVirtualGeoPainter*) G__getstructoffset())->CheckGeometry((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((const TVirtualGeoPainter*) G__getstructoffset())->CheckOverlaps((TGeoVolume*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((const TVirtualGeoPainter*) G__getstructoffset())->CheckOverlaps((TGeoVolume*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TVirtualGeoPainter*) G__getstructoffset())->CheckOverlaps((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualGeoPainter*) G__getstructoffset())->CountVisibleNodes());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->DefaultAngles();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->DefaultColors();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TVirtualGeoPainter*) G__getstructoffset())->DistanceToPrimitiveVol((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVirtualGeoPainter*) G__getstructoffset())->DrawBatemanSol((TGeoBatemanSol*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->DrawBatemanSol((TGeoBatemanSol*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVirtualGeoPainter*) G__getstructoffset())->DrawShape((TGeoShape*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->DrawShape((TGeoShape*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->DrawOnly((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualGeoPainter*) G__getstructoffset())->DrawOnly();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVirtualGeoPainter*) G__getstructoffset())->DrawOverlap((void*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->DrawOverlap((void*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->DrawCurrentPoint((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->DrawPanel();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->DrawPath((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVirtualGeoPainter*) G__getstructoffset())->DrawVolume((TGeoVolume*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->DrawVolume((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->EditGeometry((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualGeoPainter*) G__getstructoffset())->EditGeometry();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->EstimateCameraMove((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->ExecuteShapeEvent((TGeoShape*) 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__Geom1_228_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->ExecuteManagerEvent((TGeoManager*) 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__Geom1_228_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->ExecuteVolumeEvent((TGeoVolume*) 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__Geom1_228_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualGeoPainter*) G__getstructoffset())->GetColor((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualGeoPainter*) G__getstructoffset())->GetNsegments());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TVirtualGeoPainter*) G__getstructoffset())->GetBombFactors(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualGeoPainter*) G__getstructoffset())->GetBombMode());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TVirtualGeoPainter*) G__getstructoffset())->GetDrawPath());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_228_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->GetViewAngles(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualGeoPainter*) G__getstructoffset())->GetVisLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualGeoPainter*) G__getstructoffset())->GetVisOption());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TVirtualGeoPainter*) G__getstructoffset())->GetVolumeInfo((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TVirtualGeoPainter*) G__getstructoffset())->GrabFocus((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TVirtualGeoPainter*) G__getstructoffset())->GrabFocus((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TVirtualGeoPainter*) G__getstructoffset())->GrabFocus((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->GrabFocus((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualGeoPainter*) G__getstructoffset())->GrabFocus();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TVirtualGeoPainter*) G__getstructoffset())->GetViewBox());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualGeoPainter*) G__getstructoffset())->IsPaintingShape());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualGeoPainter*) G__getstructoffset())->IsRaytracing());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVirtualGeoPainter*) G__getstructoffset())->IsExplodedView());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 9:
      G__letint(result7, 85, (long) ((TVirtualGeoPainter*) G__getstructoffset())->LegoPlot(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Option_t*) G__int(libp->para[8])));
      break;
   case 8:
      G__letint(result7, 85, (long) ((TVirtualGeoPainter*) G__getstructoffset())->LegoPlot(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])));
      break;
   case 7:
      G__letint(result7, 85, (long) ((TVirtualGeoPainter*) G__getstructoffset())->LegoPlot(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((TVirtualGeoPainter*) G__getstructoffset())->LegoPlot((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((TVirtualGeoPainter*) G__getstructoffset())->LegoPlot((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TVirtualGeoPainter*) G__getstructoffset())->LegoPlot((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TVirtualGeoPainter*) G__getstructoffset())->LegoPlot((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TVirtualGeoPainter*) G__getstructoffset())->LegoPlot((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TVirtualGeoPainter*) G__getstructoffset())->LegoPlot((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TVirtualGeoPainter*) G__getstructoffset())->LegoPlot());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((const TVirtualGeoPainter*) G__getstructoffset())->ModifiedPad((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const TVirtualGeoPainter*) G__getstructoffset())->ModifiedPad();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TVirtualGeoPainter*) G__getstructoffset())->OpProgress((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]), (TStopwatch*) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5]));
      G__setnull(result7);
      break;
   case 5:
      ((TVirtualGeoPainter*) G__getstructoffset())->OpProgress((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]), (TStopwatch*) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TVirtualGeoPainter*) G__getstructoffset())->OpProgress((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]), (TStopwatch*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TVirtualGeoPainter*) G__getstructoffset())->OpProgress((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
, (Long64_t) G__Longlong(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TVirtualGeoPainter*) G__getstructoffset())->PaintNode((TGeoNode*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TVirtualGeoPainter*) G__getstructoffset())->PaintNode((TGeoNode*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->PaintNode((TGeoNode*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVirtualGeoPainter*) G__getstructoffset())->PaintShape((TGeoShape*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->PaintShape((TGeoShape*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TVirtualGeoPainter*) G__getstructoffset())->PaintOverlap((void*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->PaintOverlap((void*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TVirtualGeoPainter*) G__getstructoffset())->PrintOverlaps();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TVirtualGeoPainter*) G__getstructoffset())->PaintVolume((TGeoVolume*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (TGeoMatrix*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TVirtualGeoPainter*) G__getstructoffset())->PaintVolume((TGeoVolume*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->PaintVolume((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TVirtualGeoPainter*) G__getstructoffset())->RandomPoints((TGeoVolume*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TVirtualGeoPainter*) G__getstructoffset())->RandomPoints((TGeoVolume*) 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__Geom1_228_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->RandomRays((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->Raytrace((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualGeoPainter*) G__getstructoffset())->Raytrace();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TVirtualGeoPainter*) G__getstructoffset())->SamplePoints((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, (Double_t) G__double(libp->para[2]), (const char*) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TVirtualGeoPainter*) G__getstructoffset())->SetBombFactors((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TVirtualGeoPainter*) G__getstructoffset())->SetBombFactors((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TVirtualGeoPainter*) G__getstructoffset())->SetBombFactors((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->SetBombFactors((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualGeoPainter*) G__getstructoffset())->SetBombFactors();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->SetClippingShape((TGeoShape*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->SetExplodedView((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualGeoPainter*) G__getstructoffset())->SetExplodedView();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->SetGeoManager((TGeoManager*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->SetIteratorPlugin((TGeoIteratorPlugin*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->SetCheckedNode((TGeoNode*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->SetNsegments((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualGeoPainter*) G__getstructoffset())->SetNsegments();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->SetNmeshPoints((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->SetRaytracing((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualGeoPainter*) G__getstructoffset())->SetRaytracing();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualGeoPainter::GeoPainter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualGeoPainter::SetPainter((TVirtualGeoPainter*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->SetTopVisible((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualGeoPainter*) G__getstructoffset())->SetTopVisible();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->SetTopVolume((TGeoVolume*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->SetVisLevel((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualGeoPainter*) G__getstructoffset())->SetVisLevel();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TVirtualGeoPainter*) G__getstructoffset())->SetVisOption((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TVirtualGeoPainter*) G__getstructoffset())->SetVisOption();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVirtualGeoPainter*) G__getstructoffset())->ShapeDistancetoPrimitive((TGeoShape*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->Test((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->TestOverlaps((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVirtualGeoPainter*) G__getstructoffset())->TestVoxels((TGeoVolume*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->UnbombTranslation((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((TVirtualGeoPainter*) G__getstructoffset())->Weight((Double_t) G__double(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((TVirtualGeoPainter*) G__getstructoffset())->Weight((Double_t) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVirtualGeoPainter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualGeoPainter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVirtualGeoPainter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVirtualGeoPainter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVirtualGeoPainter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualGeoPainter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualGeoPainter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVirtualGeoPainter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_228_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVirtualGeoPainter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVirtualGeoPainter G__TTVirtualGeoPainter;
static int G__G__Geom1_228_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TVirtualGeoPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVirtualGeoPainter*) (soff+(sizeof(TVirtualGeoPainter)*i)))->~G__TTVirtualGeoPainter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVirtualGeoPainter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVirtualGeoPainter*) (soff))->~G__TTVirtualGeoPainter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_228_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVirtualGeoPainter* dest = (TVirtualGeoPainter*) G__getstructoffset();
   *dest = *(TVirtualGeoPainter*) libp->para[0].ref;
   const TVirtualGeoPainter& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoCompositeShape */
static int G__G__Geom1_230_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCompositeShape* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoCompositeShape[n];
     } else {
       p = new((void*) gvp) TGeoCompositeShape[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoCompositeShape;
     } else {
       p = new((void*) gvp) TGeoCompositeShape;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_230_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCompositeShape* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoCompositeShape((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGeoCompositeShape((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_230_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCompositeShape* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoCompositeShape((const char*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoCompositeShape((const char*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_230_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoCompositeShape* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoCompositeShape((const char*) G__int(libp->para[0]), (TGeoBoolNode*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGeoCompositeShape((const char*) G__int(libp->para[0]), (TGeoBoolNode*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_230_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoCompositeShape*) G__getstructoffset())->MakeNode((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_230_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 103, (long) ((const TGeoCompositeShape*) G__getstructoffset())->PaintComposite((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((const TGeoCompositeShape*) G__getstructoffset())->PaintComposite());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_230_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoCompositeShape*) G__getstructoffset())->RegisterYourself();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_230_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoCompositeShape::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_230_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoCompositeShape::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_230_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoCompositeShape::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_230_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoCompositeShape::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_230_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoCompositeShape*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_230_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoCompositeShape::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_230_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoCompositeShape::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_230_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoCompositeShape::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_230_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoCompositeShape::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoCompositeShape G__TTGeoCompositeShape;
static int G__G__Geom1_230_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoCompositeShape*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoCompositeShape*) (soff+(sizeof(TGeoCompositeShape)*i)))->~G__TTGeoCompositeShape();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoCompositeShape*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoCompositeShape*) (soff))->~G__TTGeoCompositeShape();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoShapeAssembly */
static int G__G__Geom1_231_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoShapeAssembly* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoShapeAssembly[n];
     } else {
       p = new((void*) gvp) TGeoShapeAssembly[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoShapeAssembly;
     } else {
       p = new((void*) gvp) TGeoShapeAssembly;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapeAssembly));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_231_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoShapeAssembly* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoShapeAssembly((TGeoVolumeAssembly*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoShapeAssembly((TGeoVolumeAssembly*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapeAssembly));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_231_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoShapeAssembly*) G__getstructoffset())->NeedsBBoxRecompute();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_231_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoShapeAssembly*) G__getstructoffset())->RecomputeBoxLast();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_231_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoShapeAssembly::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_231_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoShapeAssembly::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_231_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoShapeAssembly::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_231_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoShapeAssembly::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_231_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoShapeAssembly*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_231_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoShapeAssembly::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_231_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoShapeAssembly::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_231_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoShapeAssembly::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_231_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoShapeAssembly::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_231_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoShapeAssembly* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoShapeAssembly(*(TGeoShapeAssembly*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapeAssembly));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoShapeAssembly G__TTGeoShapeAssembly;
static int G__G__Geom1_231_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[] (TGeoShapeAssembly*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoShapeAssembly*) (soff+(sizeof(TGeoShapeAssembly)*i)))->~G__TTGeoShapeAssembly();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoShapeAssembly*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoShapeAssembly*) (soff))->~G__TTGeoShapeAssembly();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_231_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoShapeAssembly* dest = (TGeoShapeAssembly*) G__getstructoffset();
   *dest = *(TGeoShapeAssembly*) libp->para[0].ref;
   const TGeoShapeAssembly& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoScaledShape */
static int G__G__Geom1_232_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoScaledShape* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoScaledShape[n];
     } else {
       p = new((void*) gvp) TGeoScaledShape[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoScaledShape;
     } else {
       p = new((void*) gvp) TGeoScaledShape;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoScaledShape));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_232_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoScaledShape* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoScaledShape(
(const char*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoScale*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGeoScaledShape(
(const char*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoScale*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoScaledShape));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_232_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoScaledShape* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoScaledShape((TGeoShape*) G__int(libp->para[0]), (TGeoScale*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TGeoScaledShape((TGeoShape*) G__int(libp->para[0]), (TGeoScale*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoScaledShape));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Geom1_232_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoScaledShape::MakeScaledShape((const char*) G__int(libp->para[0]), (TGeoShape*) G__int(libp->para[1])
, (TGeoScale*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_232_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoScaledShape*) G__getstructoffset())->SetScale((TGeoScale*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_232_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoScaledShape::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_232_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoScaledShape::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_232_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoScaledShape::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_232_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoScaledShape::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_232_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoScaledShape*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_232_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoScaledShape::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_232_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoScaledShape::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_232_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoScaledShape::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_232_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoScaledShape::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_232_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoScaledShape* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoScaledShape(*(TGeoScaledShape*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoScaledShape));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoScaledShape G__TTGeoScaledShape;
static int G__G__Geom1_232_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[] (TGeoScaledShape*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoScaledShape*) (soff+(sizeof(TGeoScaledShape)*i)))->~G__TTGeoScaledShape();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoScaledShape*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoScaledShape*) (soff))->~G__TTGeoScaledShape();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_232_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoScaledShape* dest = (TGeoScaledShape*) G__getstructoffset();
   *dest = *(TGeoScaledShape*) libp->para[0].ref;
   const TGeoScaledShape& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoPolygon */
static int G__G__Geom1_238_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPolygon* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoPolygon[n];
     } else {
       p = new((void*) gvp) TGeoPolygon[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoPolygon;
     } else {
       p = new((void*) gvp) TGeoPolygon;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygon));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_238_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPolygon*) G__getstructoffset())->Area());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoPolygon*) G__getstructoffset())->Contains((Double_t*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPolygon*) G__getstructoffset())->FinishPolygon();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoPolygon*) G__getstructoffset())->GetNvert());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGeoPolygon*) G__getstructoffset())->GetX());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGeoPolygon*) G__getstructoffset())->GetY());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoPolygon*) G__getstructoffset())->IsClockwise());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoPolygon*) G__getstructoffset())->IsConvex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoPolygon*) G__getstructoffset())->IsFinished());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoPolygon*) G__getstructoffset())->IsIllegalCheck());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoPolygon*) G__getstructoffset())->Safety((Double_t*) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoPolygon*) G__getstructoffset())->SetConvex((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoPolygon*) G__getstructoffset())->SetConvex();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPolygon*) G__getstructoffset())->SetXY((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TGeoPolygon*) G__getstructoffset())->SetNextIndex((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TGeoPolygon*) G__getstructoffset())->SetNextIndex();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoPolygon::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPolygon::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoPolygon::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoPolygon::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoPolygon*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPolygon::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPolygon::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoPolygon::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_238_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoPolygon::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_238_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoPolygon* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoPolygon(*(TGeoPolygon*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygon));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoPolygon G__TTGeoPolygon;
static int G__G__Geom1_238_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[] (TGeoPolygon*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoPolygon*) (soff+(sizeof(TGeoPolygon)*i)))->~G__TTGeoPolygon();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoPolygon*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoPolygon*) (soff))->~G__TTGeoPolygon();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_238_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoPolygon* dest = (TGeoPolygon*) G__getstructoffset();
   *dest = *(TGeoPolygon*) libp->para[0].ref;
   const TGeoPolygon& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoXtru */
static int G__G__Geom1_240_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoXtru* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoXtru[n];
     } else {
       p = new((void*) gvp) TGeoXtru[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoXtru;
     } else {
       p = new((void*) gvp) TGeoXtru;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Geom1_240_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoXtru* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoXtru((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoXtru((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TGeoXtru*) G__getstructoffset())->DefinePolygon((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TGeoXtru*) G__getstructoffset())->DefineSection((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TGeoXtru*) G__getstructoffset())->DefineSection((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGeoXtru*) G__getstructoffset())->DefineSection((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TGeoXtru*) G__getstructoffset())->DefineSection((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoXtru*) G__getstructoffset())->GetNz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TGeoXtru*) G__getstructoffset())->GetNvert());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoXtru*) G__getstructoffset())->GetX((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoXtru*) G__getstructoffset())->GetY((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoXtru*) G__getstructoffset())->GetXOffset((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoXtru*) G__getstructoffset())->GetYOffset((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoXtru*) G__getstructoffset())->GetScale((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoXtru*) G__getstructoffset())->GetZ());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoXtru*) G__getstructoffset())->GetZ((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TGeoXtru*) G__getstructoffset())->Z((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoXtru*) G__getstructoffset())->SetCurrentZ((Double_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoXtru*) G__getstructoffset())->SetCurrentVertices((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoXtru::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoXtru::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoXtru::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoXtru::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoXtru*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoXtru::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoXtru::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoXtru::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_240_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoXtru::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoXtru G__TTGeoXtru;
static int G__G__Geom1_240_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoXtru*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoXtru*) (soff+(sizeof(TGeoXtru)*i)))->~G__TTGeoXtru();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoXtru*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoXtru*) (soff))->~G__TTGeoXtru();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoHelix */
static int G__G__Geom1_243_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoHelix* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoHelix[n];
     } else {
       p = new((void*) gvp) TGeoHelix[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoHelix;
     } else {
       p = new((void*) gvp) TGeoHelix;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelix));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoHelix* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoHelix(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TGeoHelix(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoHelix((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TGeoHelix((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelix));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHelix*) G__getstructoffset())->InitPoint((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHelix*) G__getstructoffset())->InitPoint((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGeoHelix*) G__getstructoffset())->InitDirection((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGeoHelix*) G__getstructoffset())->InitDirection((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TGeoHelix*) G__getstructoffset())->InitDirection((Double_t*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TGeoHelix*) G__getstructoffset())->InitDirection((Double_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TGeoHelix*) G__getstructoffset())->ComputeSafeStep((Double_t) G__double(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TGeoHelix*) G__getstructoffset())->ComputeSafeStep());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoHelix*) G__getstructoffset())->GetCurrentPoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TGeoHelix*) G__getstructoffset())->GetCurrentDirection());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoHelix*) G__getstructoffset())->GetXYcurvature());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoHelix*) G__getstructoffset())->GetStep());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoHelix*) G__getstructoffset())->GetTotalCurvature());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TGeoHelix*) G__getstructoffset())->IsRightHanded());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHelix*) G__getstructoffset())->ResetStep();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TGeoHelix*) G__getstructoffset())->StepToPlane((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHelix*) G__getstructoffset())->SetCharge((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHelix*) G__getstructoffset())->SetXYcurvature((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TGeoHelix*) G__getstructoffset())->SetField((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TGeoHelix*) G__getstructoffset())->SetField((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHelix*) G__getstructoffset())->SetHelixStep((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHelix*) G__getstructoffset())->Step((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHelix*) G__getstructoffset())->UpdateHelix();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoHelix::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoHelix::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoHelix::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoHelix::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHelix*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoHelix::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoHelix::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoHelix::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_243_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoHelix::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_243_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoHelix* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoHelix(*(TGeoHelix*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelix));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoHelix G__TTGeoHelix;
static int G__G__Geom1_243_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoHelix*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoHelix*) (soff+(sizeof(TGeoHelix)*i)))->~G__TTGeoHelix();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoHelix*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoHelix*) (soff))->~G__TTGeoHelix();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_243_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoHelix* dest = (TGeoHelix*) G__getstructoffset();
   *dest = *(TGeoHelix*) libp->para[0].ref;
   const TGeoHelix& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoParaboloid */
static int G__G__Geom1_245_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoParaboloid* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoParaboloid[n];
     } else {
       p = new((void*) gvp) TGeoParaboloid[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoParaboloid;
     } else {
       p = new((void*) gvp) TGeoParaboloid;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_245_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoParaboloid* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoParaboloid(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) TGeoParaboloid(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_245_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoParaboloid* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoParaboloid(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
   } else {
     p = new((void*) gvp) TGeoParaboloid(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_245_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoParaboloid* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoParaboloid((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoParaboloid((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_245_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoParaboloid*) G__getstructoffset())->DistToParaboloid((Double_t*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_245_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoParaboloid*) G__getstructoffset())->GetRlo());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_245_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoParaboloid*) G__getstructoffset())->GetRhi());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_245_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TGeoParaboloid*) G__getstructoffset())->GetDz());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_245_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoParaboloid*) G__getstructoffset())->SetParaboloidDimensions((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_245_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoParaboloid::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_245_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoParaboloid::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_245_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoParaboloid::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_245_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoParaboloid::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_245_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoParaboloid*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_245_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoParaboloid::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_245_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoParaboloid::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_245_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoParaboloid::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_245_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoParaboloid::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_245_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoParaboloid* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoParaboloid(*(TGeoParaboloid*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoParaboloid G__TTGeoParaboloid;
static int G__G__Geom1_245_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoParaboloid*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoParaboloid*) (soff+(sizeof(TGeoParaboloid)*i)))->~G__TTGeoParaboloid();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoParaboloid*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoParaboloid*) (soff))->~G__TTGeoParaboloid();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_245_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoParaboloid* dest = (TGeoParaboloid*) G__getstructoffset();
   *dest = *(TGeoParaboloid*) libp->para[0].ref;
   const TGeoParaboloid& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoHalfSpace */
static int G__G__Geom1_246_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoHalfSpace* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoHalfSpace[n];
     } else {
       p = new((void*) gvp) TGeoHalfSpace[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TGeoHalfSpace;
     } else {
       p = new((void*) gvp) TGeoHalfSpace;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_246_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoHalfSpace* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoHalfSpace(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TGeoHalfSpace(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_246_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoHalfSpace* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TGeoHalfSpace((Double_t*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TGeoHalfSpace((Double_t*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_246_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGeoHalfSpace*) G__getstructoffset())->GetPoint());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_246_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TGeoHalfSpace*) G__getstructoffset())->GetNorm());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_246_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoHalfSpace::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_246_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoHalfSpace::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_246_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoHalfSpace::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_246_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoHalfSpace::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_246_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoHalfSpace*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_246_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoHalfSpace::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_246_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoHalfSpace::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_246_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoHalfSpace::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_246_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoHalfSpace::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Geom1_246_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TGeoHalfSpace* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TGeoHalfSpace(*(TGeoHalfSpace*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoHalfSpace G__TTGeoHalfSpace;
static int G__G__Geom1_246_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoHalfSpace*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoHalfSpace*) (soff+(sizeof(TGeoHalfSpace)*i)))->~G__TTGeoHalfSpace();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoHalfSpace*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoHalfSpace*) (soff))->~G__TTGeoHalfSpace();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Geom1_246_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TGeoHalfSpace* dest = (TGeoHalfSpace*) G__getstructoffset();
   *dest = *(TGeoHalfSpace*) libp->para[0].ref;
   const TGeoHalfSpace& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TGeoBuilder */
static int G__G__Geom1_247_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoBuilder::Instance((TGeoManager*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoBuilder*) G__getstructoffset())->AddMaterial((TGeoMaterial*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoBuilder*) G__getstructoffset())->AddTransformation((TGeoMatrix*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TGeoBuilder*) G__getstructoffset())->AddShape((TGeoShape*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoBuilder*) G__getstructoffset())->RegisterMatrix((TGeoMatrix*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeArb8((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeArb8((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeBox((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeCone(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeCons(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeCtub(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
, (Double_t) G__double(libp->para[12])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeEltu((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeGtra(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
, (Double_t) G__double(libp->para[12]), (Double_t) G__double(libp->para[13])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakePara(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakePcon((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeParaboloid((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeHype(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakePgon((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeSphere(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])));
      break;
   case 7:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeSphere(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeSphere((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeSphere((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeSphere((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeTorus(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeTorus((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeTorus((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeTrap(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10]), (Double_t) G__double(libp->para[11])
, (Double_t) G__double(libp->para[12])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeTrd1((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeTrd2(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeTube((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeTubs(
(const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeXtru((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeVolumeAssembly((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->MakeVolumeMulti((const char*) G__int(libp->para[0]), (TGeoMedium*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 8:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->Division(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Option_t*) G__int(libp->para[7])));
      break;
   case 7:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->Division(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->Division((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoBuilder*) G__getstructoffset())->Matrix(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->Material(
(const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6])));
      break;
   case 6:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->Material((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])));
      break;
   case 5:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->Material((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->Mixture(
(const char*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
, (Float_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Float_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->Mixture(
(const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Double_t*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t*) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->Medium(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Double_t) G__double(libp->para[7])
, (Double_t) G__double(libp->para[8]), (Double_t) G__double(libp->para[9])
, (Double_t) G__double(libp->para[10])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 10:
      ((TGeoBuilder*) G__getstructoffset())->Node(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (Float_t*) G__int(libp->para[8]), (Int_t) G__int(libp->para[9]));
      G__setnull(result7);
      break;
   case 9:
      ((TGeoBuilder*) G__getstructoffset())->Node(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (Float_t*) G__int(libp->para[8]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 10:
      ((TGeoBuilder*) G__getstructoffset())->Node(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (Double_t*) G__int(libp->para[8]), (Int_t) G__int(libp->para[9]));
      G__setnull(result7);
      break;
   case 9:
      ((TGeoBuilder*) G__getstructoffset())->Node(
(const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (Double_t*) G__int(libp->para[8]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->Volume((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->Volume((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->Volume((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TGeoBuilder*) G__getstructoffset())->Volume((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Double_t*) G__int(libp->para[3])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TGeoBuilder::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoBuilder::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TGeoBuilder::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TGeoBuilder::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TGeoBuilder*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoBuilder::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoBuilder::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TGeoBuilder::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Geom1_247_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TGeoBuilder::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TGeoBuilder G__TTGeoBuilder;
static int G__G__Geom1_247_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TGeoBuilder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TGeoBuilder*) (soff+(sizeof(TGeoBuilder)*i)))->~G__TTGeoBuilder();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TGeoBuilder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TGeoBuilder*) (soff))->~G__TTGeoBuilder();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* TGeoAtt */

/* TGeoShape */

/* TGeoMatrix */

/* TGeoHMatrix */

/* TGeoBoolNode */

/* TGeoUnion */

/* TGeoIntersection */

/* TGeoSubtraction */

/* TGeoElementTable */

/* TGeoIsotope */

/* TGeoElement */

/* TGeoDecayChannel */

/* TGeoBatemanSol */

/* TGeoElementRN */

/* TGeoElemIter */

/* TGeoMaterial */

/* TGeoMixture */

/* TGeoMedium */

/* TGeoTranslation */

/* TGeoRotation */

/* TGeoScale */

/* TGeoCombiTrans */

/* TGeoGenTrans */

/* TGeoIdentity */

/* TGeoBBox */

/* TGeoVolume */

/* TGeoNode */

/* TGeoVoxelFinder */

/* TGeoManager */

/* TGeoVolumeMulti */

/* TGeoVolumeAssembly */

/* TGeoNodeMatrix */

/* TGeoNodeOffset */

/* TGeoIterator */

/* TGeoIteratorPlugin */

/* TGeoPara */

/* TGeoTube */

/* TGeoTubeSeg */

/* TGeoCtub */

/* TGeoTorus */

/* TGeoSphere */

/* TGeoEltu */

/* TGeoHype */

/* TGeoCone */

/* TGeoConeSeg */

/* TGeoPcon */

/* TGeoPgon */

/* TGeoArb8 */

/* TGeoTrap */

/* TGeoGtra */

/* TGeoTrd1 */

/* TGeoTrd2 */

/* TGeoNavigator */

/* TVirtualGeoTrack */

/* TGeoPhysicalNode */

/* TGeoPNEntry */

/* TVirtualGeoPainter */

/* TGeoCompositeShape */

/* TGeoShapeAssembly */

/* TGeoScaledShape */

/* TGeoPolygon */

/* TGeoXtru */

/* TGeoHelix */

/* TGeoParaboloid */

/* TGeoHalfSpace */

/* TGeoBuilder */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__Geom1 {
 public:
  G__Sizep2memfuncG__Geom1(): p(&G__Sizep2memfuncG__Geom1::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__Geom1::*p)();
};

size_t G__get_sizep2memfuncG__Geom1()
{
  G__Sizep2memfuncG__Geom1 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__Geom1() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape))) {
     TGeoShape *G__Lderived;
     G__Lderived=(TGeoShape*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix))) {
     TGeoMatrix *G__Lderived;
     G__Lderived=(TGeoMatrix*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix))) {
     TGeoHMatrix *G__Lderived;
     G__Lderived=(TGeoHMatrix*)0x1000;
     {
       TGeoMatrix *G__Lpbase=(TGeoMatrix*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix),G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNode))) {
     TGeoBoolNode *G__Lderived;
     G__Lderived=(TGeoBoolNode*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNode),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoUnion))) {
     TGeoUnion *G__Lderived;
     G__Lderived=(TGeoUnion*)0x1000;
     {
       TGeoBoolNode *G__Lpbase=(TGeoBoolNode*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoUnion),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNode),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoUnion),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIntersection))) {
     TGeoIntersection *G__Lderived;
     G__Lderived=(TGeoIntersection*)0x1000;
     {
       TGeoBoolNode *G__Lpbase=(TGeoBoolNode*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIntersection),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNode),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIntersection),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoSubtraction))) {
     TGeoSubtraction *G__Lderived;
     G__Lderived=(TGeoSubtraction*)0x1000;
     {
       TGeoBoolNode *G__Lpbase=(TGeoBoolNode*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoSubtraction),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNode),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoSubtraction),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable))) {
     TGeoElementTable *G__Lderived;
     G__Lderived=(TGeoElementTable*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIsotope))) {
     TGeoIsotope *G__Lderived;
     G__Lderived=(TGeoIsotope*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIsotope),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIsotope),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement))) {
     TGeoElement *G__Lderived;
     G__Lderived=(TGeoElement*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannel))) {
     TGeoDecayChannel *G__Lderived;
     G__Lderived=(TGeoDecayChannel*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannel),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol))) {
     TGeoBatemanSol *G__Lderived;
     G__Lderived=(TGeoBatemanSol*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol),G__get_linked_tagnum(&G__G__Geom1LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol),G__get_linked_tagnum(&G__G__Geom1LN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol),G__get_linked_tagnum(&G__G__Geom1LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN))) {
     TGeoElementRN *G__Lderived;
     G__Lderived=(TGeoElementRN*)0x1000;
     {
       TGeoElement *G__Lpbase=(TGeoElement*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN),G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial))) {
     TGeoMaterial *G__Lderived;
     G__Lderived=(TGeoMaterial*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial),G__get_linked_tagnum(&G__G__Geom1LN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture))) {
     TGeoMixture *G__Lderived;
     G__Lderived=(TGeoMixture*)0x1000;
     {
       TGeoMaterial *G__Lpbase=(TGeoMaterial*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture),G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture),G__get_linked_tagnum(&G__G__Geom1LN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium))) {
     TGeoMedium *G__Lderived;
     G__Lderived=(TGeoMedium*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation))) {
     TGeoTranslation *G__Lderived;
     G__Lderived=(TGeoTranslation*)0x1000;
     {
       TGeoMatrix *G__Lpbase=(TGeoMatrix*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation),G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation))) {
     TGeoRotation *G__Lderived;
     G__Lderived=(TGeoRotation*)0x1000;
     {
       TGeoMatrix *G__Lpbase=(TGeoMatrix*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation),G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale))) {
     TGeoScale *G__Lderived;
     G__Lderived=(TGeoScale*)0x1000;
     {
       TGeoMatrix *G__Lpbase=(TGeoMatrix*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale),G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans))) {
     TGeoCombiTrans *G__Lderived;
     G__Lderived=(TGeoCombiTrans*)0x1000;
     {
       TGeoMatrix *G__Lpbase=(TGeoMatrix*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans),G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans))) {
     TGeoGenTrans *G__Lderived;
     G__Lderived=(TGeoGenTrans*)0x1000;
     {
       TGeoCombiTrans *G__Lpbase=(TGeoCombiTrans*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans),G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoMatrix *G__Lpbase=(TGeoMatrix*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans),G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIdentity))) {
     TGeoIdentity *G__Lderived;
     G__Lderived=(TGeoIdentity*)0x1000;
     {
       TGeoMatrix *G__Lpbase=(TGeoMatrix*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIdentity),G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIdentity),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIdentity),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox))) {
     TGeoBBox *G__Lderived;
     G__Lderived=(TGeoBBox*)0x1000;
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume))) {
     TGeoVolume *G__Lderived;
     G__Lderived=(TGeoVolume*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGeoAtt *G__Lpbase=(TGeoAtt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),G__get_linked_tagnum(&G__G__Geom1LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),G__get_linked_tagnum(&G__G__Geom1LN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),G__get_linked_tagnum(&G__G__Geom1LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode))) {
     TGeoNode *G__Lderived;
     G__Lderived=(TGeoNode*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGeoAtt *G__Lpbase=(TGeoAtt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder))) {
     TGeoVoxelFinder *G__Lderived;
     G__Lderived=(TGeoVoxelFinder*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager))) {
     TGeoManager *G__Lderived;
     G__Lderived=(TGeoManager*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti))) {
     TGeoVolumeMulti *G__Lderived;
     G__Lderived=(TGeoVolumeMulti*)0x1000;
     {
       TGeoVolume *G__Lpbase=(TGeoVolume*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti),G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGeoAtt *G__Lpbase=(TGeoAtt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti),G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti),G__get_linked_tagnum(&G__G__Geom1LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti),G__get_linked_tagnum(&G__G__Geom1LN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti),G__get_linked_tagnum(&G__G__Geom1LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly))) {
     TGeoVolumeAssembly *G__Lderived;
     G__Lderived=(TGeoVolumeAssembly*)0x1000;
     {
       TGeoVolume *G__Lpbase=(TGeoVolume*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly),G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGeoAtt *G__Lpbase=(TGeoAtt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly),G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly),G__get_linked_tagnum(&G__G__Geom1LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly),G__get_linked_tagnum(&G__G__Geom1LN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAtt3D *G__Lpbase=(TAtt3D*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly),G__get_linked_tagnum(&G__G__Geom1LN_TAtt3D),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix))) {
     TGeoNodeMatrix *G__Lderived;
     G__Lderived=(TGeoNodeMatrix*)0x1000;
     {
       TGeoNode *G__Lpbase=(TGeoNode*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix),G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGeoAtt *G__Lpbase=(TGeoAtt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix),G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset))) {
     TGeoNodeOffset *G__Lderived;
     G__Lderived=(TGeoNodeOffset*)0x1000;
     {
       TGeoNode *G__Lpbase=(TGeoNode*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset),G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGeoAtt *G__Lpbase=(TGeoAtt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset),G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIteratorPlugin))) {
     TGeoIteratorPlugin *G__Lderived;
     G__Lderived=(TGeoIteratorPlugin*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIteratorPlugin),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara))) {
     TGeoPara *G__Lderived;
     G__Lderived=(TGeoPara*)0x1000;
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube))) {
     TGeoTube *G__Lderived;
     G__Lderived=(TGeoTube*)0x1000;
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg))) {
     TGeoTubeSeg *G__Lderived;
     G__Lderived=(TGeoTubeSeg*)0x1000;
     {
       TGeoTube *G__Lpbase=(TGeoTube*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg),G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub))) {
     TGeoCtub *G__Lderived;
     G__Lderived=(TGeoCtub*)0x1000;
     {
       TGeoTubeSeg *G__Lpbase=(TGeoTubeSeg*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub),G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoTube *G__Lpbase=(TGeoTube*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub),G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus))) {
     TGeoTorus *G__Lderived;
     G__Lderived=(TGeoTorus*)0x1000;
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere))) {
     TGeoSphere *G__Lderived;
     G__Lderived=(TGeoSphere*)0x1000;
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu))) {
     TGeoEltu *G__Lderived;
     G__Lderived=(TGeoEltu*)0x1000;
     {
       TGeoTube *G__Lpbase=(TGeoTube*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu),G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype))) {
     TGeoHype *G__Lderived;
     G__Lderived=(TGeoHype*)0x1000;
     {
       TGeoTube *G__Lpbase=(TGeoTube*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype),G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone))) {
     TGeoCone *G__Lderived;
     G__Lderived=(TGeoCone*)0x1000;
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg))) {
     TGeoConeSeg *G__Lderived;
     G__Lderived=(TGeoConeSeg*)0x1000;
     {
       TGeoCone *G__Lpbase=(TGeoCone*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg),G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon))) {
     TGeoPcon *G__Lderived;
     G__Lderived=(TGeoPcon*)0x1000;
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon))) {
     TGeoPgon *G__Lderived;
     G__Lderived=(TGeoPgon*)0x1000;
     {
       TGeoPcon *G__Lpbase=(TGeoPcon*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon),G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8))) {
     TGeoArb8 *G__Lderived;
     G__Lderived=(TGeoArb8*)0x1000;
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap))) {
     TGeoTrap *G__Lderived;
     G__Lderived=(TGeoTrap*)0x1000;
     {
       TGeoArb8 *G__Lpbase=(TGeoArb8*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap),G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra))) {
     TGeoGtra *G__Lderived;
     G__Lderived=(TGeoGtra*)0x1000;
     {
       TGeoTrap *G__Lpbase=(TGeoTrap*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra),G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoArb8 *G__Lpbase=(TGeoArb8*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra),G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1))) {
     TGeoTrd1 *G__Lderived;
     G__Lderived=(TGeoTrd1*)0x1000;
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2))) {
     TGeoTrd2 *G__Lderived;
     G__Lderived=(TGeoTrd2*)0x1000;
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNavigator))) {
     TGeoNavigator *G__Lderived;
     G__Lderived=(TGeoNavigator*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNavigator),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack))) {
     TVirtualGeoTrack *G__Lderived;
     G__Lderived=(TVirtualGeoTrack*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoAtt *G__Lpbase=(TGeoAtt*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack),G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack),G__get_linked_tagnum(&G__G__Geom1LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack),G__get_linked_tagnum(&G__G__Geom1LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode))) {
     TGeoPhysicalNode *G__Lderived;
     G__Lderived=(TGeoPhysicalNode*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode),G__get_linked_tagnum(&G__G__Geom1LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPNEntry))) {
     TGeoPNEntry *G__Lderived;
     G__Lderived=(TGeoPNEntry*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPNEntry),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPNEntry),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPainter))) {
     TVirtualGeoPainter *G__Lderived;
     G__Lderived=(TVirtualGeoPainter*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPainter),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape))) {
     TGeoCompositeShape *G__Lderived;
     G__Lderived=(TGeoCompositeShape*)0x1000;
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapeAssembly))) {
     TGeoShapeAssembly *G__Lderived;
     G__Lderived=(TGeoShapeAssembly*)0x1000;
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapeAssembly),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapeAssembly),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapeAssembly),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapeAssembly),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoScaledShape))) {
     TGeoScaledShape *G__Lderived;
     G__Lderived=(TGeoScaledShape*)0x1000;
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoScaledShape),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoScaledShape),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoScaledShape),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoScaledShape),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygon))) {
     TGeoPolygon *G__Lderived;
     G__Lderived=(TGeoPolygon*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygon),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru))) {
     TGeoXtru *G__Lderived;
     G__Lderived=(TGeoXtru*)0x1000;
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelix))) {
     TGeoHelix *G__Lderived;
     G__Lderived=(TGeoHelix*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelix),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid))) {
     TGeoParaboloid *G__Lderived;
     G__Lderived=(TGeoParaboloid*)0x1000;
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace))) {
     TGeoHalfSpace *G__Lderived;
     G__Lderived=(TGeoHalfSpace*)0x1000;
     {
       TGeoBBox *G__Lpbase=(TGeoBBox*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace),G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TGeoShape *G__Lpbase=(TGeoShape*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace),G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace),G__get_linked_tagnum(&G__G__Geom1LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBuilder))) {
     TGeoBuilder *G__Lderived;
     G__Lderived=(TGeoBuilder*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBuilder),G__get_linked_tagnum(&G__G__Geom1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__Geom1() {

   /* 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("ULong_t",107,-1,0,-1);
   G__setnewtype(-1,"Unsigned long integer 4 bytes (unsigned long)",0);
   G__search_typename2("Float_t",102,-1,0,-1);
   G__setnewtype(-1,"Float 4 bytes (float)",0);
   G__search_typename2("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Bool_t",103,-1,0,-1);
   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("Option_t",99,-1,256,-1);
   G__setnewtype(-1,"Option string (const char)",0);
   G__search_typename2("Long64_t",110,-1,0,-1);
   G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__Geom1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Geom1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Geom1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Geom1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Geom1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__Geom1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Geom1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Geom1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Geom1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Geom1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__Geom1LN_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__Geom1LN_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__Geom1LN_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__Geom1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("BtCoef_t",117,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSolcLcLBtCoef_t),0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<Int_t,TGeoElementRN*>",117,G__get_linked_tagnum(&G__G__Geom1LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,TGeoElementRN*>",117,G__get_linked_tagnum(&G__G__Geom1LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,TGeoElementRN*,less<int> >",117,G__get_linked_tagnum(&G__G__Geom1LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ElementRNMap_t",117,G__get_linked_tagnum(&G__G__Geom1LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ElementRNMapIt_t",117,G__get_linked_tagnum(&G__G__Geom1LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable));
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TGeoAtt */
static void G__setup_memvarTGeoAtt(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt));
   { TGeoAtt *p; p=(TGeoAtt*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kBitMask=%lldLL",(long long)TGeoAtt::kBitMask).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,G__FastAllocString(2048).Format("kVisOverride=%lldLL",(long long)TGeoAtt::kVisOverride).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,G__FastAllocString(2048).Format("kVisNone=%lldLL",(long long)TGeoAtt::kVisNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,G__FastAllocString(2048).Format("kVisThis=%lldLL",(long long)TGeoAtt::kVisThis).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,G__FastAllocString(2048).Format("kVisDaughters=%lldLL",(long long)TGeoAtt::kVisDaughters).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,G__FastAllocString(2048).Format("kVisOneLevel=%lldLL",(long long)TGeoAtt::kVisOneLevel).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,G__FastAllocString(2048).Format("kVisStreamed=%lldLL",(long long)TGeoAtt::kVisStreamed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,G__FastAllocString(2048).Format("kVisTouched=%lldLL",(long long)TGeoAtt::kVisTouched).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,G__FastAllocString(2048).Format("kVisOnScreen=%lldLL",(long long)TGeoAtt::kVisOnScreen).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,G__FastAllocString(2048).Format("kVisContainers=%lldLL",(long long)TGeoAtt::kVisContainers).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,G__FastAllocString(2048).Format("kVisOnly=%lldLL",(long long)TGeoAtt::kVisOnly).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,G__FastAllocString(2048).Format("kVisBranch=%lldLL",(long long)TGeoAtt::kVisBranch).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt),-1,-2,1,G__FastAllocString(2048).Format("kVisRaytrace=%lldLL",(long long)TGeoAtt::kVisRaytrace).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoActivityAtt),-1,-2,1,G__FastAllocString(2048).Format("kActOverride=%lldLL",(long long)TGeoAtt::kActOverride).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoActivityAtt),-1,-2,1,G__FastAllocString(2048).Format("kActNone=%lldLL",(long long)TGeoAtt::kActNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoActivityAtt),-1,-2,1,G__FastAllocString(2048).Format("kActThis=%lldLL",(long long)TGeoAtt::kActThis).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoActivityAtt),-1,-2,1,G__FastAllocString(2048).Format("kActDaughters=%lldLL",(long long)TGeoAtt::kActDaughters).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoOptimizationAtt),-1,-2,1,G__FastAllocString(2048).Format("kUseBoundingBox=%lldLL",(long long)TGeoAtt::kUseBoundingBox).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoOptimizationAtt),-1,-2,1,G__FastAllocString(2048).Format("kUseVoxels=%lldLL",(long long)TGeoAtt::kUseVoxels).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoOptimizationAtt),-1,-2,1,G__FastAllocString(2048).Format("kUseGsord=%lldLL",(long long)TGeoAtt::kUseGsord).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoSavePrimitiveAtt),-1,-2,1,G__FastAllocString(2048).Format("kSavePrimitiveAtt=%lldLL",(long long)TGeoAtt::kSavePrimitiveAtt).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoAttcLcLEGeoSavePrimitiveAtt),-1,-2,1,G__FastAllocString(2048).Format("kSaveNodesAtt=%lldLL",(long long)TGeoAtt::kSaveNodesAtt).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fGeoAtt=",0,"option flags");
   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__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoShape */
static void G__setup_memvarTGeoShape(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape));
   { TGeoShape *p; p=(TGeoShape*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix),-1,-2,4,"fgTransform=",0,"current transformation matrix that applies to shape");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-2,4,"fgEpsMch=",0,"Machine round-off error");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kBitMask32=%lldLL",(long long)TGeoShape::kBitMask32).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoNoShape=%lldLL",(long long)TGeoShape::kGeoNoShape).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoBad=%lldLL",(long long)TGeoShape::kGeoBad).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoRSeg=%lldLL",(long long)TGeoShape::kGeoRSeg).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoPhiSeg=%lldLL",(long long)TGeoShape::kGeoPhiSeg).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoThetaSeg=%lldLL",(long long)TGeoShape::kGeoThetaSeg).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoVisX=%lldLL",(long long)TGeoShape::kGeoVisX).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoVisY=%lldLL",(long long)TGeoShape::kGeoVisY).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoVisZ=%lldLL",(long long)TGeoShape::kGeoVisZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoRunTimeShape=%lldLL",(long long)TGeoShape::kGeoRunTimeShape).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoInvalidShape=%lldLL",(long long)TGeoShape::kGeoInvalidShape).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoTorus=%lldLL",(long long)TGeoShape::kGeoTorus).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoBox=%lldLL",(long long)TGeoShape::kGeoBox).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoPara=%lldLL",(long long)TGeoShape::kGeoPara).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoSph=%lldLL",(long long)TGeoShape::kGeoSph).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoTube=%lldLL",(long long)TGeoShape::kGeoTube).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoTubeSeg=%lldLL",(long long)TGeoShape::kGeoTubeSeg).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoCone=%lldLL",(long long)TGeoShape::kGeoCone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoConeSeg=%lldLL",(long long)TGeoShape::kGeoConeSeg).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoPcon=%lldLL",(long long)TGeoShape::kGeoPcon).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoPgon=%lldLL",(long long)TGeoShape::kGeoPgon).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoArb8=%lldLL",(long long)TGeoShape::kGeoArb8).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoEltu=%lldLL",(long long)TGeoShape::kGeoEltu).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoTrap=%lldLL",(long long)TGeoShape::kGeoTrap).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoCtub=%lldLL",(long long)TGeoShape::kGeoCtub).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoTrd1=%lldLL",(long long)TGeoShape::kGeoTrd1).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoTrd2=%lldLL",(long long)TGeoShape::kGeoTrd2).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoComb=%lldLL",(long long)TGeoShape::kGeoComb).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoClosedShape=%lldLL",(long long)TGeoShape::kGeoClosedShape).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoXtru=%lldLL",(long long)TGeoShape::kGeoXtru).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoParaboloid=%lldLL",(long long)TGeoShape::kGeoParaboloid).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoHalfSpace=%lldLL",(long long)TGeoShape::kGeoHalfSpace).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoHype=%lldLL",(long long)TGeoShape::kGeoHype).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapecLcLEShapeType),-1,-2,1,G__FastAllocString(2048).Format("kGeoSavePrimitive=%lldLL",(long long)TGeoShape::kGeoSavePrimitive).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fShapeId=",0,"shape id");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fShapeBits=",0,"shape bits");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoMatrix */
static void G__setup_memvarTGeoMatrix(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix));
   { TGeoMatrix *p; p=(TGeoMatrix*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,G__FastAllocString(2048).Format("kGeoIdentity=%lldLL",(long long)TGeoMatrix::kGeoIdentity).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,G__FastAllocString(2048).Format("kGeoTranslation=%lldLL",(long long)TGeoMatrix::kGeoTranslation).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,G__FastAllocString(2048).Format("kGeoRotation=%lldLL",(long long)TGeoMatrix::kGeoRotation).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,G__FastAllocString(2048).Format("kGeoScale=%lldLL",(long long)TGeoMatrix::kGeoScale).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,G__FastAllocString(2048).Format("kGeoReflection=%lldLL",(long long)TGeoMatrix::kGeoReflection).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,G__FastAllocString(2048).Format("kGeoRegistered=%lldLL",(long long)TGeoMatrix::kGeoRegistered).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,G__FastAllocString(2048).Format("kGeoSavePrimitive=%lldLL",(long long)TGeoMatrix::kGeoSavePrimitive).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,G__FastAllocString(2048).Format("kGeoMatrixOwned=%lldLL",(long long)TGeoMatrix::kGeoMatrixOwned).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,G__FastAllocString(2048).Format("kGeoCombiTrans=%lldLL",(long long)TGeoMatrix::kGeoCombiTrans).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes),-1,-2,1,G__FastAllocString(2048).Format("kGeoGenTrans=%lldLL",(long long)TGeoMatrix::kGeoGenTrans).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoHMatrix */
static void G__setup_memvarTGeoHMatrix(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix));
   { TGeoHMatrix *p; p=(TGeoHMatrix*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTranslation[3]=",0,"translation component");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRotationMatrix[9]=",0,"rotation matrix");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fScale[3]=",0,"scale component");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoBoolNode */
static void G__setup_memvarTGeoBoolNode(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNode));
   { TGeoBoolNode *p; p=(TGeoBoolNode*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNodecLcLEGeoBoolType),-1,-2,1,G__FastAllocString(2048).Format("kGeoUnion=%lldLL",(long long)TGeoBoolNode::kGeoUnion).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNodecLcLEGeoBoolType),-1,-2,1,G__FastAllocString(2048).Format("kGeoIntersection=%lldLL",(long long)TGeoBoolNode::kGeoIntersection).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNodecLcLEGeoBoolType),-1,-2,1,G__FastAllocString(2048).Format("kGeoSubtraction=%lldLL",(long long)TGeoBoolNode::kGeoSubtraction).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSelected=",0,"! selected branch");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),-1,-1,2,"fLeft=",0,"shape on the left branch");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),-1,-1,2,"fRight=",0,"shape on the right branch");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix),-1,-1,2,"fLeftMat=",0,"transformation that applies to the left branch");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix),-1,-1,2,"fRightMat=",0,"transformation that applies to the right branch");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpoints=",0,"! number of points on the mesh");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPoints=",0,"! array of mesh points");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoUnion */
static void G__setup_memvarTGeoUnion(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoUnion));
   { TGeoUnion *p; p=(TGeoUnion*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoIntersection */
static void G__setup_memvarTGeoIntersection(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIntersection));
   { TGeoIntersection *p; p=(TGeoIntersection*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoSubtraction */
static void G__setup_memvarTGeoSubtraction(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoSubtraction));
   { TGeoSubtraction *p; p=(TGeoSubtraction*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoElementTable */
static void G__setup_memvarTGeoElementTable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable));
   { TGeoElementTable *p; p=(TGeoElementTable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNelements=",0,"number of elements");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNelementsRN=",0,"number of RN elements");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNisotopes=",0,"number of isotopes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fList=",0,"list of elements");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fListRN=",0,"list of RN elements");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fIsotopes=",0,"list of user-defined isotopes");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Geom1LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR),G__defined_typename("ElementRNMap_t"),-1,4,"fElementsRN=",0,"! map of RN elements with ENDF key");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTablecLcLEGeoETStatus),-1,-2,1,G__FastAllocString(2048).Format("kETDefaultElements=%lldLL",(long long)TGeoElementTable::kETDefaultElements).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTablecLcLEGeoETStatus),-1,-2,1,G__FastAllocString(2048).Format("kETRNElements=%lldLL",(long long)TGeoElementTable::kETRNElements).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoIsotope */
static void G__setup_memvarTGeoIsotope(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIsotope));
   { TGeoIsotope *p; p=(TGeoIsotope*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fZ=",0,"atomic number");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fN=",0,"number of nucleons");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fA=",0,"atomic mass (g/mole)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoElement */
static void G__setup_memvarTGeoElement(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement));
   { TGeoElement *p; p=(TGeoElement*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementcLcLEGeoElement),-1,-2,2,"kElemUsed=131072LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementcLcLEGeoElement),-1,-2,2,"kElemDefined=262144LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementcLcLEGeoElement),-1,-2,2,"kElementChecked=524288LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fZ=",0,"Z of element");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fN=",0,"Number of nucleons");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNisotopes=",0,"Number of isotopes for the element");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fA=",0,"A of element");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,2,"fIsotopes=",0,"List of isotopes");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAbundances=",0,"[fNisotopes] Array of relative isotope abundances");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoDecayChannel */
static void G__setup_memvarTGeoDecayChannel(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannel));
   { TGeoDecayChannel *p; p=(TGeoDecayChannel*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fDecay=",0,"Decay mode");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDiso=",0,"Delta isomeric number");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fBranchingRatio=",0,"Branching Ratio");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fQvalue=",0,"Qvalue in GeV");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN),-1,-1,4,"fParent=",0,"Parent element");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN),-1,-1,4,"fDaughter=",0,"Daughter element");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode),-1,-2,1,G__FastAllocString(2048).Format("kBitMask32=%lldLL",(long long)TGeoDecayChannel::kBitMask32).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode),-1,-2,1,G__FastAllocString(2048).Format("k2BetaMinus=%lldLL",(long long)TGeoDecayChannel::k2BetaMinus).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode),-1,-2,1,G__FastAllocString(2048).Format("kBetaMinus=%lldLL",(long long)TGeoDecayChannel::kBetaMinus).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode),-1,-2,1,G__FastAllocString(2048).Format("kNeutronEm=%lldLL",(long long)TGeoDecayChannel::kNeutronEm).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode),-1,-2,1,G__FastAllocString(2048).Format("kProtonEm=%lldLL",(long long)TGeoDecayChannel::kProtonEm).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode),-1,-2,1,G__FastAllocString(2048).Format("kAlpha=%lldLL",(long long)TGeoDecayChannel::kAlpha).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode),-1,-2,1,G__FastAllocString(2048).Format("kECF=%lldLL",(long long)TGeoDecayChannel::kECF).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode),-1,-2,1,G__FastAllocString(2048).Format("kElecCapt=%lldLL",(long long)TGeoDecayChannel::kElecCapt).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode),-1,-2,1,G__FastAllocString(2048).Format("kIsoTrans=%lldLL",(long long)TGeoDecayChannel::kIsoTrans).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode),-1,-2,1,G__FastAllocString(2048).Format("kI=%lldLL",(long long)TGeoDecayChannel::kI).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode),-1,-2,1,G__FastAllocString(2048).Format("kSpontFiss=%lldLL",(long long)TGeoDecayChannel::kSpontFiss).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode),-1,-2,1,G__FastAllocString(2048).Format("k2P=%lldLL",(long long)TGeoDecayChannel::k2P).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode),-1,-2,1,G__FastAllocString(2048).Format("k2N=%lldLL",(long long)TGeoDecayChannel::k2N).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode),-1,-2,1,G__FastAllocString(2048).Format("k2A=%lldLL",(long long)TGeoDecayChannel::k2A).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode),-1,-2,1,G__FastAllocString(2048).Format("kCarbon12=%lldLL",(long long)TGeoDecayChannel::kCarbon12).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode),-1,-2,1,G__FastAllocString(2048).Format("kCarbon14=%lldLL",(long long)TGeoDecayChannel::kCarbon14).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoBatemanSol */
static void G__setup_memvarTGeoBatemanSol(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol));
   { TGeoBatemanSol *p; p=(TGeoBatemanSol*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN),-1,-1,4,"fElem=",0,"Referred RN element");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN),-1,-1,4,"fElemTop=",0,"Top RN element");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCsize=",0,"Size of the array of coefficients");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNcoeff=",0,"Number of coefficients");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fFactor=",0,"Constant factor that applies to all coefficients");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTmin=",0,"Minimum value of the time interval");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTmax=",0,"Maximum value of the time interval");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSolcLcLBtCoef_t),G__defined_typename("BtCoef_t"),-1,4,"fCoeff=",0,"[fNcoeff] Array of coefficients");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoElementRN */
static void G__setup_memvarTGeoElementRN(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN));
   { TGeoElementRN *p; p=(TGeoElementRN*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fENDFcode=",0,"ENDF element code");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIso=",0,"Isomer number");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLevel=",0,"Isomeric level");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDeltaM=",0,"Mass excess");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fHalfLife=",0,"Half life");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fNatAbun=",0,"Natural Abundance");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTH_F=",0,"Hynalation toxicity");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTG_F=",0,"Ingestion toxicity");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTH_S=",0,"Hynalation toxicity");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTG_S=",0,"Ingestion toxicity");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fStatus=",0,"Status code");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol),-1,-1,2,"fRatio=",0,"Time evolution of proportion by number");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,2,"fDecays=",0,"List of decay modes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoElemIter */
static void G__setup_memvarTGeoElemIter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElemIter));
   { TGeoElemIter *p; p=(TGeoElemIter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN),-1,-1,4,"fTop=",0,"Top element of the iteration");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN),-1,-1,4,"fElem=",0,"Current element");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fBranch=",0,"Current branch");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLevel=",0,"Current level");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLimitRatio=",0,"Minimum cumulative branching ratio");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRatio=",0,"Current ratio");
   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__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoMaterial */
static void G__setup_memvarTGeoMaterial(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial));
   { TGeoMaterial *p; p=(TGeoMaterial*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterial),-1,-2,1,G__FastAllocString(2048).Format("kMatUsed=%lldLL",(long long)TGeoMaterial::kMatUsed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterial),-1,-2,1,G__FastAllocString(2048).Format("kMatSavePrimitive=%lldLL",(long long)TGeoMaterial::kMatSavePrimitive).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterialState),-1,-2,1,G__FastAllocString(2048).Format("kMatStateUndefined=%lldLL",(long long)TGeoMaterial::kMatStateUndefined).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterialState),-1,-2,1,G__FastAllocString(2048).Format("kMatStateSolid=%lldLL",(long long)TGeoMaterial::kMatStateSolid).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterialState),-1,-2,1,G__FastAllocString(2048).Format("kMatStateLiquid=%lldLL",(long long)TGeoMaterial::kMatStateLiquid).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterialState),-1,-2,1,G__FastAllocString(2048).Format("kMatStateGas=%lldLL",(long long)TGeoMaterial::kMatStateGas).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIndex=",0,"material index");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fA=",0,"A of material");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ=",0,"Z of material");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDensity=",0,"density of material");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRadLen=",0,"radiation length");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fIntLen=",0,"interaction length");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTemperature=",0,"temperature");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPressure=",0,"pressure");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterialState),-1,-1,2,"fState=",0,"material state");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObject),-1,-1,2,"fShader=",0,"shader with optical properties");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObject),-1,-1,2,"fCerenkov=",0,"pointer to class with Cerenkov properties");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement),-1,-1,2,"fElement=",0,"pointer to element composing the material");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoMixture */
static void G__setup_memvarTGeoMixture(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture));
   { TGeoMixture *p; p=(TGeoMixture*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNelements=",0,"number of elements");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZmixture=",0,"[fNelements] array of Z of the elements");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAmixture=",0,"[fNelements] array of A of the elements");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fWeights=",0,"[fNelements] array of relative proportions by mass");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNatoms=",0,"[fNelements] array of numbers of atoms");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,2,"fElements=",0,"array of elements composing the mixture");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoMedium */
static void G__setup_memvarTGeoMedium(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium));
   { TGeoMedium *p; p=(TGeoMedium*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMediumcLcLEGeoMedium),-1,-2,1,G__FastAllocString(2048).Format("kMedSavePrimitive=%lldLL",(long long)TGeoMedium::kMedSavePrimitive).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fId=",0,"unique Id");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fParams[20]=",0,"parameters");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial),-1,-1,2,"fMaterial=",0,"pointer to material");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoTranslation */
static void G__setup_memvarTGeoTranslation(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation));
   { TGeoTranslation *p; p=(TGeoTranslation*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTranslation[3]=",0,"translation vector");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoRotation */
static void G__setup_memvarTGeoRotation(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation));
   { TGeoRotation *p; p=(TGeoRotation*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRotationMatrix[9]=",0,"rotation matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoScale */
static void G__setup_memvarTGeoScale(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale));
   { TGeoScale *p; p=(TGeoScale*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fScale[3]=",0,"scale (x, y, z)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoCombiTrans */
static void G__setup_memvarTGeoCombiTrans(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans));
   { TGeoCombiTrans *p; p=(TGeoCombiTrans*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTranslation[3]=",0,"translation vector");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation),-1,-1,2,"fRotation=",0,"rotation matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoGenTrans */
static void G__setup_memvarTGeoGenTrans(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans));
   { TGeoGenTrans *p; p=(TGeoGenTrans*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fScale[3]=",0,"scale (x, y, z)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoIdentity */
static void G__setup_memvarTGeoIdentity(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIdentity));
   { TGeoIdentity *p; p=(TGeoIdentity*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoBBox */
static void G__setup_memvarTGeoBBox(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox));
   { TGeoBBox *p; p=(TGeoBBox*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDX=",0,"X half-length");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDY=",0,"Y half-length");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDZ=",0,"Z half-length");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fOrigin[3]=",0,"box origin");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoVolume */
static void G__setup_memvarTGeoVolume(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume));
   { TGeoVolume *p; p=(TGeoVolume*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,2,"fNodes=",0,"array of nodes inside this volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),-1,-1,2,"fShape=",0,"shape");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium),-1,-1,2,"fMedium=",0,"tracking medium");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPatternFinder),-1,-1,2,"fFinder=",0,"finder object for divisions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder),-1,-1,2,"fVoxels=",0,"finder object for bounding boxes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager),-1,-1,2,"fGeoManager=",0,"! pointer to TGeoManager owning this volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObject),-1,-1,2,"fField=",0,"! just a hook for now");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TString),-1,-1,2,"fOption=",0,"! option - if any");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumber=",0,"volume serial number in the list of volumes");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNtotal=",0,"total number of physical nodes");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes),-1,-2,1,G__FastAllocString(2048).Format("kVolumeReplicated=%lldLL",(long long)TGeoVolume::kVolumeReplicated).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes),-1,-2,1,G__FastAllocString(2048).Format("kVolumeSelected=%lldLL",(long long)TGeoVolume::kVolumeSelected).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes),-1,-2,1,G__FastAllocString(2048).Format("kVolumeDiv=%lldLL",(long long)TGeoVolume::kVolumeDiv).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes),-1,-2,1,G__FastAllocString(2048).Format("kVolumeOverlap=%lldLL",(long long)TGeoVolume::kVolumeOverlap).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes),-1,-2,1,G__FastAllocString(2048).Format("kVolumeImportNodes=%lldLL",(long long)TGeoVolume::kVolumeImportNodes).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes),-1,-2,1,G__FastAllocString(2048).Format("kVolumeMulti=%lldLL",(long long)TGeoVolume::kVolumeMulti).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes),-1,-2,1,G__FastAllocString(2048).Format("kVoxelsXYZ=%lldLL",(long long)TGeoVolume::kVoxelsXYZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes),-1,-2,1,G__FastAllocString(2048).Format("kVoxelsCyl=%lldLL",(long long)TGeoVolume::kVoxelsCyl).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes),-1,-2,1,G__FastAllocString(2048).Format("kVolumeClone=%lldLL",(long long)TGeoVolume::kVolumeClone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes),-1,-2,1,G__FastAllocString(2048).Format("kVolumeAdded=%lldLL",(long long)TGeoVolume::kVolumeAdded).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoNode */
static void G__setup_memvarTGeoNode(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode));
   { TGeoNode *p; p=(TGeoNode*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,-1,2,"fVolume=",0,"volume associated with this");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,-1,2,"fMother=",0,"mother volume");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumber=",0,"copy number");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNovlp=",0,"number of overlaps");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOverlaps=",0,"[fNovlp] list of indices for overlapping brothers");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kGeoNodeMatrix=%lldLL",(long long)TGeoNode::kGeoNodeMatrix).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kGeoNodeOffset=%lldLL",(long long)TGeoNode::kGeoNodeOffset).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kGeoNodeVC=%lldLL",(long long)TGeoNode::kGeoNodeVC).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kGeoNodeOverlap=%lldLL",(long long)TGeoNode::kGeoNodeOverlap).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoVoxelFinder */
static void G__setup_memvarTGeoVoxelFinder(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder));
   { TGeoVoxelFinder *p; p=(TGeoVoxelFinder*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFindercLcLEVoxelsType),-1,-2,1,G__FastAllocString(2048).Format("kGeoInvalidVoxels=%lldLL",(long long)TGeoVoxelFinder::kGeoInvalidVoxels).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFindercLcLEVoxelsType),-1,-2,1,G__FastAllocString(2048).Format("kGeoRebuildVoxels=%lldLL",(long long)TGeoVoxelFinder::kGeoRebuildVoxels).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,-1,2,"fVolume=",0,"volume to which applies");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNcandidates=",0,"! number of candidates");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCurrentVoxel=",0,"! index of current voxel in sorted list");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIbx=",0,"number of different boundaries on X axis");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIby=",0,"number of different boundaries on Y axis");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIbz=",0,"number of different boundaries on Z axis");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNboxes=",0,"length of boxes array");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNox=",0,"length of array of X offsets");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNoy=",0,"length of array of Y offsets");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNoz=",0,"length of array of Z offsets");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNex=",0,"length of array of X extra offsets");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNey=",0,"length of array of Y extra offsets");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNez=",0,"length of array of Z extra offsets");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNx=",0,"length of array of X voxels");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNy=",0,"length of array of Y voxels");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNz=",0,"length of array of Z voxels");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPriority[3]=",0,"priority for each axis");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSlices[3]=",0,"! slice indices for current voxel");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fInc[3]=",0,"! slice index increment");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fInvdir[3]=",0,"! 1/current director cosines");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLimits[3]=",0,"limits on X,Y,Z");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fBoxes=",0,"[fNboxes] list of bounding boxes");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXb=",0,"[fIbx] ordered array of X box boundaries");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYb=",0,"[fIby] ordered array of Y box boundaries");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZb=",0,"[fIbz] ordered array of Z box boundaries");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOBx=",0,"[fNox] offsets of daughter indices for slices X");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOBy=",0,"[fNoy] offsets of daughter indices for slices Y");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOBz=",0,"[fNoz] offsets of daughter indices for slices Z");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOEx=",0,"[fNox] offsets of extra indices for slices X");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOEy=",0,"[fNoy] offsets of extra indices for slices Y");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fOEz=",0,"[fNoz] offsets of extra indices for slices Z");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fExtraX=",0,"[fNex] indices of extra daughters in X slices");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fExtraY=",0,"[fNey] indices of extra daughters in Y slices");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fExtraZ=",0,"[fNez] indices of extra daughters in Z slices");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNsliceX=",0,"[fNox] number of candidates in X slice");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNsliceY=",0,"[fNoy] number of candidates in Y slice");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNsliceZ=",0,"[fNoz] number of candidates in Z slice");
   G__memvar_setup((void*)0,66,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fIndcX=",0,"[fNx] array of slices bits on X");
   G__memvar_setup((void*)0,66,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fIndcY=",0,"[fNy] array of slices bits on Y");
   G__memvar_setup((void*)0,66,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fIndcZ=",0,"[fNz] array of slices bits on Z");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCheckList=",0,"! list of candidates");
   G__memvar_setup((void*)0,66,0,0,-1,G__defined_typename("UChar_t"),-1,2,"fBits1=",0,"! bits used for list intersection");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoManager */
static void G__setup_memvarTGeoManager(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager));
   { TGeoManager *p; p=(TGeoManager*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,2,"fgLock=",0,"! Lock preventing a second geometry to be loaded");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fgVerboseLevel=",0,"! Verbosity level for Info messages (no IO).");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhimin=",0,"! lowest range for phi cut");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhimax=",0,"! highest range for phi cut");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTmin=",0,"! lower time limit for tracks drawing");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTmax=",0,"! upper time limit for tracks drawing");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNNodes=",0,"total number of physical nodes");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TString),-1,-1,4,"fPath=",0,"! path to current node");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TString),-1,-1,4,"fParticleName=",0,"! particles to be drawn");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fVisDensity=",0,"transparency threshold by density");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fExplodedView=",0,"exploded view mode");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fVisOption=",0,"global visualization option");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fVisLevel=",0,"maximum visualization depth");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNsegments=",0,"number of segments to approximate circles");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNtracks=",0,"number of tracks");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxVisNodes=",0,"maximum number of visible nodes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack),-1,-1,4,"fCurrentTrack=",0,"! current track");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNpdg=",0,"number of different pdg's stored");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPdgId[256]=",0,"pdg conversion table");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fClosed=",0,"! flag that geometry is closed");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fLoopVolumes=",0,"! flag volume lists loop");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fStreamVoxels=",0,"flag to allow voxelization I/O");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsGeomReading=",0,"! flag set when reading geometry");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fPhiCut=",0,"flag for phi cuts");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTimeCut=",0,"time cut for tracks");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDrawExtra=",0,"! flag that the list of physical nodes has to be drawn");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMatrixTransform=",0,"! flag for using GL matrix");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMatrixReflection=",0,"! flag for GL reflections");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fActivity=",0,"! switch ON/OFF volume activity (default OFF - all volumes active))");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsNodeSelectable=",0,"! flag that nodes are the selected objects in pad rather than volumes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPainter),-1,-1,4,"fPainter=",0,"! current painter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fMatrices=",0,"-> list of local transformations");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fShapes=",0,"-> list of shapes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fVolumes=",0,"-> list of volumes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fPhysicalNodes=",0,"-> list of physical nodes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fGShapes=",0,"! list of runtime shapes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fGVolumes=",0,"! list of runtime volumes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fTracks=",0,"-> list of tracks attached to geometry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fPdgNames=",0,"-> list of pdg names for tracks");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fNavigators=",0,"! list of navigators");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TList),-1,-1,4,"fMaterials=",0,"-> list of materials");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TList),-1,-1,4,"fMedia=",0,"-> list of tracking media");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fNodes=",0,"-> current branch of nodes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fOverlaps=",0,"-> list of geometrical overlaps");
   G__memvar_setup((void*)0,66,0,0,-1,G__defined_typename("UChar_t"),-1,4,"fBits=",0,"! bits used for voxelization");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNavigator),-1,-1,4,"fCurrentNavigator=",0,"! current navigator");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,-1,4,"fCurrentVolume=",0,"! current volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,-1,4,"fTopVolume=",0,"! top level volume in geometry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),-1,-1,4,"fTopNode=",0,"! top physical node");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,-1,4,"fMasterVolume=",0,"master volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix),-1,-1,4,"fGLMatrix=",0,"matrix to be used for view transformations");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fUniqueVolumes=",0,"-> list of unique volumes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),-1,-1,4,"fClippingShape=",0,"! clipping shape for raytracing");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable),-1,-1,4,"fElementTable=",0,"! table of elements");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNodeIdArray=",0,"! array of node id's");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIntSize=",0,"! int buffer size");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDblSize=",0,"! dbl buffer size");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIntBuffer=",0,"! transient int buffer");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNLevel=",0,"maximum accepted level in geometry");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDblBuffer=",0,"! transient dbl buffer");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,-1,4,"fPaintVolume=",0,"! volume currently painted");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_THashList),-1,-1,4,"fHashVolumes=",0,"! hash list of volumes providing fast search");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_THashList),-1,-1,4,"fHashGVolumes=",0,"! hash list of group volumes providing fast search");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_THashList),-1,-1,4,"fHashPNE=",0,"-> hash list of phisical node entries");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fArrayPNE=",0,"! array of phisical node entries");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSizePNEId=",0,"size of the array of unique ID's for PN entries");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNPNEId=",0,"number of PN entries having a unique ID");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fKeyPNEId=",0,"[fSizePNEId] array of uid values for PN entries");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fValuePNEId=",0,"[fSizePNEId] array of pointers to PN entries with ID's");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoVolumeMulti */
static void G__setup_memvarTGeoVolumeMulti(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti));
   { TGeoVolumeMulti *p; p=(TGeoVolumeMulti*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,4,"fVolumes=",0,"list of volumes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti),-1,-1,4,"fDivision=",0,"division of this volume");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNumed=",0,"medium number for divisions");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNdiv=",0,"number of divisions");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fAxis=",0,"axis of division");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fStart=",0,"division start offset");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fStep=",0,"division step");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fAttSet=",0,"flag attributes set");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoVolumeAssembly */
static void G__setup_memvarTGeoVolumeAssembly(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly));
   { TGeoVolumeAssembly *p; p=(TGeoVolumeAssembly*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCurrent=",0,"! index of current selected node");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNext=",0,"! index of next node to be entered");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoNodeMatrix */
static void G__setup_memvarTGeoNodeMatrix(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix));
   { TGeoNodeMatrix *p; p=(TGeoNodeMatrix*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix),-1,-1,4,"fMatrix=",0,"transf. matrix of fNode in fMother system");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoNodeOffset */
static void G__setup_memvarTGeoNodeOffset(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset));
   { TGeoNodeOffset *p; p=(TGeoNodeOffset*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fOffset=",0,"X offset for this node with respect to its mother");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIndex=",0,"index of this node in the division");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPatternFinder),-1,-1,4,"fFinder=",0,"finder for this node");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoIterator */
static void G__setup_memvarTGeoIterator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIterator));
   { TGeoIterator *p; p=(TGeoIterator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,-1,4,"fTop=",0,"Top volume of the iterated branch");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMustResume=",0,"Private flag to resume from current node.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMustStop=",0,"Private flag to signal that the iterator has finished.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLevel=",0,"Current level in the tree");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fType=",0,"Type of iteration");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fArray=",0,"Array of node indices for the current path");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix),-1,-1,4,"fMatrix=",0,"Current global matrix");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TString),-1,-1,4,"fTopName=",0,"User name for top");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoIteratorPlugin),-1,-1,4,"fPlugin=",0,"User iterator plugin");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fPluginAutoexec=",0,"Plugin automatically executed during next()                 ");
   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__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoIteratorPlugin */
static void G__setup_memvarTGeoIteratorPlugin(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIteratorPlugin));
   { TGeoIteratorPlugin *p; p=(TGeoIteratorPlugin*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoIterator),-1,-1,2,"fIterator=",0,"Caller iterator");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoPara */
static void G__setup_memvarTGeoPara(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara));
   { TGeoPara *p; p=(TGeoPara*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX=",0,"X half-length");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY=",0,"Y half-length");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ=",0,"Z half-length");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAlpha=",0,"angle w.r.t Y from the center of low Y to the hihg Y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTheta=",0,"polar angle of segment between low and hi Z surfaces    ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi=",0,"azimuthal angle of segment between low and hi Z surfaces ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTxy=",0,"tangent of XY section angle");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTxz=",0,"tangent of XZ section angle");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTyz=",0,"tangent of XZ section angle");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoTube */
static void G__setup_memvarTGeoTube(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube));
   { TGeoTube *p; p=(TGeoTube*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmin=",0,"inner radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmax=",0,"outer radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDz=",0,"half length");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoTubeSeg */
static void G__setup_memvarTGeoTubeSeg(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg));
   { TGeoTubeSeg *p; p=(TGeoTubeSeg*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi1=",0,"first phi limit ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi2=",0,"second phi limit ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoCtub */
static void G__setup_memvarTGeoCtub(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub));
   { TGeoCtub *p; p=(TGeoCtub*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fNlow[3]=",0,"normal to lower cut plane ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fNhigh[3]=",0,"normal to highet cut plane ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoTorus */
static void G__setup_memvarTGeoTorus(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus));
   { TGeoTorus *p; p=(TGeoTorus*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fR=",0,"axial radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmin=",0,"inner radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmax=",0,"outer radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi1=",0,"starting phi");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDphi=",0,"phi extent");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoSphere */
static void G__setup_memvarTGeoSphere(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere));
   { TGeoSphere *p; p=(TGeoSphere*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNz=",0,"number of z planes for drawing");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNseg=",0,"number of segments for drawing");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmin=",0,"inner radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmax=",0,"outer radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTheta1=",0,"lower theta limit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTheta2=",0,"higher theta limit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi1=",0,"lower phi limit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi2=",0,"higher phi limit");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoEltu */
static void G__setup_memvarTGeoEltu(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu));
   { TGeoEltu *p; p=(TGeoEltu*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoHype */
static void G__setup_memvarTGeoHype(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype));
   { TGeoHype *p; p=(TGeoHype*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fStIn=",0,"Stereo angle for inner surface");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fStOut=",0,"Stereo angle for inner surface");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTin=",0,"Tangent of stereo angle for inner surface");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTout=",0,"Tangent of stereo angle for outer surface");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTinsq=",0,"Squared tangent of stereo angle for inner surface");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fToutsq=",0,"Squared tangent of stereo angle for outer surface");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoCone */
static void G__setup_memvarTGeoCone(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone));
   { TGeoCone *p; p=(TGeoCone*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDz=",0,"half length");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmin1=",0,"inner radius at -dz");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmax1=",0,"outer radius at -dz");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmin2=",0,"inner radius at +dz");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmax2=",0,"outer radius at +dz");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoConeSeg */
static void G__setup_memvarTGeoConeSeg(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg));
   { TGeoConeSeg *p; p=(TGeoConeSeg*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi1=",0,"first phi limit ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi2=",0,"second phi limit ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoPcon */
static void G__setup_memvarTGeoPcon(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon));
   { TGeoPcon *p; p=(TGeoPcon*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNz=",0,"number of z planes (at least two)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi1=",0,"lower phi limit ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDphi=",0,"phi range");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmin=",0,"[fNz] pointer to array of inner radii ");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmax=",0,"[fNz] pointer to array of outer radii ");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ=",0,"[fNz] pointer to array of Z planes positions ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoPgon */
static void G__setup_memvarTGeoPgon(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon));
   { TGeoPgon *p; p=(TGeoPgon*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNedges=",0,"number of edges (at least one)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoArb8 */
static void G__setup_memvarTGeoArb8(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8));
   { TGeoArb8 *p; p=(TGeoArb8*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8cLcLEGeoArb8Type),-1,-2,2,"kArb8Trap=134217728LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8cLcLEGeoArb8Type),-1,-2,2,"kArb8Tra=268435456LL",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDz=",0,"half length in Z");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTwist=",0,"! [4] tangents of twist angles ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXY[8][2]=",0,"list of vertices");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoTrap */
static void G__setup_memvarTGeoTrap(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap));
   { TGeoTrap *p; p=(TGeoTrap*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTheta=",0,"theta angle");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi=",0,"phi angle");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fH1=",0,"half length in y at low z");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fBl1=",0,"half length in x at low z and y low edge");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTl1=",0,"half length in x at low z and y high edge");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAlpha1=",0,"angle between centers of x edges an y axis at low z");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fH2=",0,"half length in y at high z");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fBl2=",0,"half length in x at high z and y low edge");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTl2=",0,"half length in x at high z and y high edge");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAlpha2=",0,"angle between centers of x edges an y axis at low z");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoGtra */
static void G__setup_memvarTGeoGtra(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra));
   { TGeoGtra *p; p=(TGeoGtra*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTwistAngle=",0,"twist angle in degrees");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoTrd1 */
static void G__setup_memvarTGeoTrd1(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1));
   { TGeoTrd1 *p; p=(TGeoTrd1*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDx1=",0,"half length in X at lower Z surface (-dz)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDx2=",0,"half length in X at higher Z surface (+dz)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDy=",0,"half length in Y");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDz=",0,"half length in Z");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoTrd2 */
static void G__setup_memvarTGeoTrd2(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2));
   { TGeoTrd2 *p; p=(TGeoTrd2*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDx1=",0,"half length in X at lower Z surface (-dz)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDx2=",0,"half length in X at higher Z surface (+dz)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDy1=",0,"half length in Y at lower Z surface (-dz)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDy2=",0,"half length in Y at higher Z surface (+dz)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDz=",0,"half length in Z");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoNavigator */
static void G__setup_memvarTGeoNavigator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNavigator));
   { TGeoNavigator *p; p=(TGeoNavigator*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fStep=",0,"! step to be done from current point and direction");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSafety=",0,"! safety radius from current point");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLastSafety=",0,"! last computed safety radius");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNormal[3]=",0,"! cosine of incident angle on current checked surface");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCldir[3]=",0,"! unit vector to current closest shape");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCldirChecked[3]=",0,"! unit vector to current checked shape");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPoint[3]=",0,"! current point");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDirection[3]=",0,"! current direction");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLastPoint[3]=",0,"! last point for which safety was computed");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLevel=",0,"! current geometry level;");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNmany=",0,"! number of overlapping nodes on current branch");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNextDaughterIndex=",0,"! next daughter index after FindNextBoundary");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOverlapSize=",0,"! current size of fOverlapClusters");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOverlapMark=",0,"! current recursive position in fOverlapClusters");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOverlapClusters=",0,"! internal array for overlaps");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSearchOverlaps=",0,"! flag set when an overlapping cluster is searched");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fCurrentOverlapping=",0,"! flags the type of the current node");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fStartSafe=",0,"! flag a safe start for point classification");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsEntering=",0,"! flag if current step just got into a new node");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsExiting=",0,"! flag that current track is about to leave current node");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsStepEntering=",0,"! flag that next geometric step will enter new volume");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsStepExiting=",0,"! flaag that next geometric step will exit current volume");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsOutside=",0,"! flag that current point is outside geometry");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsOnBoundary=",0,"! flag that current point is on some boundary");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsSameLocation=",0,"! flag that a new point is in the same node as previous");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsNullStep=",0,"! flag that last geometric step was null");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager),-1,-1,4,"fGeometry=",0,"! current geometry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeCache),-1,-1,4,"fCache=",0,"! cache of states");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume),-1,-1,4,"fCurrentVolume=",0,"! current volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),-1,-1,4,"fCurrentNode=",0,"! current node    ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),-1,-1,4,"fTopNode=",0,"! top physical node");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),-1,-1,4,"fLastNode=",0,"! last searched node");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),-1,-1,4,"fNextNode=",0,"! next node that will be crossed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode),-1,-1,4,"fForcedNode=",0,"! current point is supposed to be inside this node");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoCacheState),-1,-1,4,"fBackupState=",0,"! backup state");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix),-1,-1,4,"fCurrentMatrix=",0,"! current stored global matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix),-1,-1,4,"fGlobalMatrix=",0,"! current pointer to cached global matrix");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TString),-1,-1,4,"fPath=",0,"! path to current node");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualGeoTrack */
static void G__setup_memvarTVirtualGeoTrack(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack));
   { TVirtualGeoTrack *p; p=(TVirtualGeoTrack*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPDG=",0,"track pdg code");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fId=",0,"track id");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack),-1,-1,2,"fParent=",0,"id of parent");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObject),-1,-1,2,"fParticle=",0,"particle for this track");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,2,"fTracks=",0,"daughter tracks");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoPhysicalNode */
static void G__setup_memvarTGeoPhysicalNode(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode));
   { TGeoPhysicalNode *p; p=(TGeoPhysicalNode*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLevel=",0,"depth in the geometry tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,2,"fMatrices=",0,"global transformation matrices");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,2,"fNodes=",0,"branch of nodes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix),-1,-1,2,"fMatrixOrig=",0,"original local matrix of the last node in the path");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNodecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kGeoPNodeFull=%lldLL",(long long)TGeoPhysicalNode::kGeoPNodeFull).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNodecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kGeoPNodeVisible=%lldLL",(long long)TGeoPhysicalNode::kGeoPNodeVisible).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNodecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kGeoPNodeVolAtt=%lldLL",(long long)TGeoPhysicalNode::kGeoPNodeVolAtt).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNodecLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kGeoPNodeAligned=%lldLL",(long long)TGeoPhysicalNode::kGeoPNodeAligned).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoPNEntry */
static void G__setup_memvarTGeoPNEntry(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPNEntry));
   { TGeoPNEntry *p; p=(TGeoPNEntry*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPNEntrycLcLEPNEntryFlags),-1,-2,4,"kPNEntryOwnMatrix=16384LL",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode),-1,-1,4,"fNode=",0,"Physical node to which this applies");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix),-1,-1,4,"fMatrix=",0,"Additional matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix),-1,-1,4,"fGlobalOrig=",0,"Original global matrix for the linked physical node");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVirtualGeoPainter */
static void G__setup_memvarTVirtualGeoPainter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPainter));
   { TVirtualGeoPainter *p; p=(TVirtualGeoPainter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPainter),-1,-2,2,"fgGeoPainter=",0,"Pointer to class painter");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisLevel),-1,-2,1,G__FastAllocString(2048).Format("kGeoVisLevel=%lldLL",(long long)TVirtualGeoPainter::kGeoVisLevel).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisOption),-1,-2,1,G__FastAllocString(2048).Format("kGeoVisDefault=%lldLL",(long long)TVirtualGeoPainter::kGeoVisDefault).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisOption),-1,-2,1,G__FastAllocString(2048).Format("kGeoVisLeaves=%lldLL",(long long)TVirtualGeoPainter::kGeoVisLeaves).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisOption),-1,-2,1,G__FastAllocString(2048).Format("kGeoVisOnly=%lldLL",(long long)TVirtualGeoPainter::kGeoVisOnly).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisOption),-1,-2,1,G__FastAllocString(2048).Format("kGeoVisBranch=%lldLL",(long long)TVirtualGeoPainter::kGeoVisBranch).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisOption),-1,-2,1,G__FastAllocString(2048).Format("kGeoVisChanged=%lldLL",(long long)TVirtualGeoPainter::kGeoVisChanged).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoBombOption),-1,-2,1,G__FastAllocString(2048).Format("kGeoNoBomb=%lldLL",(long long)TVirtualGeoPainter::kGeoNoBomb).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoBombOption),-1,-2,1,G__FastAllocString(2048).Format("kGeoBombXYZ=%lldLL",(long long)TVirtualGeoPainter::kGeoBombXYZ).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoBombOption),-1,-2,1,G__FastAllocString(2048).Format("kGeoBombCyl=%lldLL",(long long)TVirtualGeoPainter::kGeoBombCyl).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoBombOption),-1,-2,1,G__FastAllocString(2048).Format("kGeoBombSph=%lldLL",(long long)TVirtualGeoPainter::kGeoBombSph).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoCompositeShape */
static void G__setup_memvarTGeoCompositeShape(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape));
   { TGeoCompositeShape *p; p=(TGeoCompositeShape*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNode),-1,-1,4,"fNode=",0,"top boolean node");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoShapeAssembly */
static void G__setup_memvarTGeoShapeAssembly(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapeAssembly));
   { TGeoShapeAssembly *p; p=(TGeoShapeAssembly*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCurrent=",0,"! node number for current node");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNext=",0,"! node number for next crossed node");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly),-1,-1,2,"fVolume=",0,"assembly volume");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fBBoxOK=",0,"has bounding box been calculated");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoScaledShape */
static void G__setup_memvarTGeoScaledShape(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoScaledShape));
   { TGeoScaledShape *p; p=(TGeoScaledShape*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape),-1,-1,2,"fShape=",0,"pointer to an existing shape");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale),-1,-1,2,"fScale=",0,"pointer to a scale transformation");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoPolygon */
static void G__setup_memvarTGeoPolygon(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygon));
   { TGeoPolygon *p; p=(TGeoPolygon*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygoncLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kGeoConvex=%lldLL",(long long)TGeoPolygon::kGeoConvex).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygoncLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kGeoFinishPolygon=%lldLL",(long long)TGeoPolygon::kGeoFinishPolygon).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygoncLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kGeoACW=%lldLL",(long long)TGeoPolygon::kGeoACW).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNvert=",0,"number of vertices (must be defined clockwise in XY plane)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNconvex=",0,"number of points of the outscribed convex polygon ");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fInd=",0,"[fNvert] list of vertex indices");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIndc=",0,"[fNconvex] indices of vertices of the outscribed convex polygon");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX=",0,"! pointer to list of current X coordinates of vertices");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY=",0,"! pointer to list of current Y coordinates of vertices");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TObjArray),-1,-1,2,"fDaughters=",0,"list of concave daughters");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoXtru */
static void G__setup_memvarTGeoXtru(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru));
   { TGeoXtru *p; p=(TGeoXtru*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNvert=",0,"number of vertices of the 2D polygon (at least 3)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNz=",0,"number of z planes (at least two)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZcurrent=",0,"current Z position");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygon),-1,-1,2,"fPoly=",0,"polygon defining section shape");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX=",0,"[fNvert] X positions for polygon vertices");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY=",0,"[fNvert] Y positions for polygon vertices");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXc=",0,"[fNvert] current X positions for polygon vertices");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYc=",0,"[fNvert] current Y positions for polygon vertices");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZ=",0,"[fNz] array of Z planes positions ");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fScale=",0,"[fNz] array of scale factors (for each Z)");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fX0=",0,"[fNz] array of X offsets (for each Z)");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fY0=",0,"[fNz] array of Y offsets (for each Z)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fSeg=",0,"!current segment [0,fNvert-1]");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIz=",0,"!current z plane [0,fNz-1]");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoHelix */
static void G__setup_memvarTGeoHelix(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelix));
   { TGeoHelix *p; p=(TGeoHelix*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fC=",0,"curvature in XY plane");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fS=",0,"Z step of the helix / 2*PI");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fStep=",0,"current step");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPhi=",0,"phi angle");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPointInit[3]=",0,"initial point");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDirInit[3]=",0,"normalized initial direction");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPoint[3]=",0,"point after a step");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDir[3]=",0,"direction after a step");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fB[3]=",0,"normalized direction for magnetic field");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fQ=",0,"right/left-handed (+/- 1) - \"charge\"");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix),-1,-1,4,"fMatrix=",0,"transformation of local helix frame to MARS   ");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelixcLcLEGeoHelixTypes),-1,-2,1,G__FastAllocString(2048).Format("kHelixNeedUpdate=%lldLL",(long long)TGeoHelix::kHelixNeedUpdate).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelixcLcLEGeoHelixTypes),-1,-2,1,G__FastAllocString(2048).Format("kHelixStraigth=%lldLL",(long long)TGeoHelix::kHelixStraigth).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelixcLcLEGeoHelixTypes),-1,-2,1,G__FastAllocString(2048).Format("kHelixCircle=%lldLL",(long long)TGeoHelix::kHelixCircle).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoParaboloid */
static void G__setup_memvarTGeoParaboloid(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid));
   { TGeoParaboloid *p; p=(TGeoParaboloid*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRlo=",0,"radius at z=-dz");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRhi=",0,"radius at z=+dz");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDz=",0,"range on Z axis [-dz, dz]");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fA=",0,"quadratic coeff.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fB=",0,"Z value of parabola at x=y=0");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoHalfSpace */
static void G__setup_memvarTGeoHalfSpace(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace));
   { TGeoHalfSpace *p; p=(TGeoHalfSpace*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fP[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fN[3]=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TGeoBuilder */
static void G__setup_memvarTGeoBuilder(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBuilder));
   { TGeoBuilder *p; p=(TGeoBuilder*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoBuilder),-1,-2,2,"fgInstance=",0,"! static pointer to singleton");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager),-1,-1,4,"fGeometry=",0,"! current geometry");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__Geom1() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTGeoAtt(void) {
   /* TGeoAtt */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt));
   G__memfunc_setup("TGeoAtt",664,G__G__Geom1_99_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoAtt",664,G__G__Geom1_99_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt), -1, 0, 3, 1, 1, 0, 
"C - 'Option_t' 10 - vis_opt C - 'Option_t' 10 '\"\"' activity_opt "
"C - 'Option_t' 10 '\"\"' optimization_opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAttBit",884,G__G__Geom1_99_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAttBit",884,G__G__Geom1_99_0_4, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - f g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetAttBit",1099,G__G__Geom1_99_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TestAttBit",1000,G__G__Geom1_99_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVisRaytrace",1433,G__G__Geom1_99_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVisBranch",1196,G__G__Geom1_99_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVisContainers",1652,G__G__Geom1_99_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVisLeaves",1214,G__G__Geom1_99_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVisOnly",1024,G__G__Geom1_99_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVisibility",1364,G__G__Geom1_99_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' vis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVisDaughters",1541,G__G__Geom1_99_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' vis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVisStreamed",1427,G__G__Geom1_99_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' vis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVisTouched",1322,G__G__Geom1_99_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' vis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetActivity",1145,G__G__Geom1_99_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetActiveDaughters",1839,G__G__Geom1_99_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOptimization",1587,G__G__Geom1_99_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsActive",792,G__G__Geom1_99_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsActiveDaughters",1727,G__G__Geom1_99_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisRaytrace",1321,G__G__Geom1_99_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisible",906,G__G__Geom1_99_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisDaughters",1429,G__G__Geom1_99_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisBranch",1084,G__G__Geom1_99_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisContainers",1540,G__G__Geom1_99_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisLeaves",1102,G__G__Geom1_99_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisOnly",912,G__G__Geom1_99_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisStreamed",1315,G__G__Geom1_99_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisTouched",1210,G__G__Geom1_99_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_99_0_30, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoAtt::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_99_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoAtt::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_99_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoAtt::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_99_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoAtt::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Geom1_99_0_34, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Geom1_99_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_99_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_99_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__Geom1_99_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoAtt::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_99_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoAtt::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_99_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoAtt::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_99_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoAtt::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoAtt", 664, G__G__Geom1_99_0_42, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt), -1, 0, 1, 1, 1, 0, "u 'TGeoAtt' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoAtt", 790, G__G__Geom1_99_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_99_0_44, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoAtt), -1, 1, 1, 1, 1, 0, "u 'TGeoAtt' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoShape(void) {
   /* TGeoShape */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape));
   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("GetBasicColor",1281,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOnBoundary",1325,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TransformPoints",1593,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"D - 'Double_t' 0 - points h - 'UInt_t' 0 - NbPoints", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Big",274,G__G__Geom1_105_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Double_t (*)())(&TGeoShape::Big) ), 0);
   G__memfunc_setup("GetTransform",1244,G__G__Geom1_105_0_8, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TGeoMatrix* (*)())(&TGeoShape::GetTransform) ), 0);
   G__memfunc_setup("SetTransform",1256,G__G__Geom1_105_0_9, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TGeoMatrix' - 0 - matrix", (char*)NULL, (void*) G__func2void( (void (*)(TGeoMatrix*))(&TGeoShape::SetTransform) ), 0);
   G__memfunc_setup("Tolerance",925,G__G__Geom1_105_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Double_t (*)())(&TGeoShape::Tolerance) ), 0);
   G__memfunc_setup("ComputeEpsMch",1309,G__G__Geom1_105_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Double_t (*)())(&TGeoShape::ComputeEpsMch) ), 0);
   G__memfunc_setup("EpsMch",576,G__G__Geom1_105_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Double_t (*)())(&TGeoShape::EpsMch) ), 0);
   G__memfunc_setup("Capacity",814,G__G__Geom1_105_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ComputeBBox",1096,G__G__Geom1_105_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_105_0_15, 121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Contains",831,G__G__Geom1_105_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CouldBeCrossed",1393,G__G__Geom1_105_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DistFromInside",1412,G__G__Geom1_105_0_19, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DistFromOutside",1541,G__G__Geom1_105_0_20, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DistToPhiMin",1180,G__G__Geom1_105_0_21, 100, -1, G__defined_typename("Double_t"), 0, 9, 3, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"d - 'Double_t' 0 - s1 d - 'Double_t' 0 - c1 "
"d - 'Double_t' 0 - s2 d - 'Double_t' 0 - c2 "
"d - 'Double_t' 0 - sm d - 'Double_t' 0 - cm "
"g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t*, Double_t*, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Bool_t))(&TGeoShape::DistToPhiMin) ), 0);
   G__memfunc_setup("Divide",597,G__G__Geom1_105_0_22, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisName",1078,G__G__Geom1_105_0_25, 67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - iaxis", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetAxisRange",1186,G__G__Geom1_105_0_26, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - iaxis d - 'Double_t' 1 - xlo "
"d - 'Double_t' 1 - xhi", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetBoundingCylinder",1936,G__G__Geom1_105_0_27, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetBuffer3D",1009,G__G__Geom1_105_0_28, 117, G__get_linked_tagnum(&G__G__Geom1LN_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("GetByteCount",1213,G__G__Geom1_105_0_29, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPointsOnSegments",1952,G__G__Geom1_105_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - npoints D - 'Double_t' 0 - array", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetFittingBox",1310,G__G__Geom1_105_0_31, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 8, 
"U 'TGeoBBox' - 10 - parambox U 'TGeoMatrix' - 0 - mat "
"d - 'Double_t' 1 - dx d - 'Double_t' 1 - dy "
"d - 'Double_t' 1 - dz", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetId",461,G__G__Geom1_105_0_32, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMakeRuntimeShape",1907,G__G__Geom1_105_0_33, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMeshNumbers",1417,G__G__Geom1_105_0_34, 121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - - i - 'Int_t' 1 - - "
"i - 'Int_t' 1 - -", (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("GetNmeshVertices",1632,G__G__Geom1_105_0_36, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointerName",1410,G__G__Geom1_105_0_37, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsAssembly",1020,G__G__Geom1_105_0_38, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsComposite",1135,G__G__Geom1_105_0_39, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCylType",902,G__G__Geom1_105_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsCloseToPhi",1174,G__G__Geom1_105_0_41, 103, -1, G__defined_typename("Bool_t"), 0, 6, 3, 1, 0, 
"d - 'Double_t' 0 - epsil D - 'Double_t' 0 - point "
"d - 'Double_t' 0 - c1 d - 'Double_t' 0 - s1 "
"d - 'Double_t' 0 - c2 d - 'Double_t' 0 - s2", (char*)NULL, (void*) G__func2void( (Bool_t (*)(Double_t, Double_t*, Double_t, Double_t, Double_t, Double_t))(&TGeoShape::IsCloseToPhi) ), 0);
   G__memfunc_setup("IsCrossingSemiplane",1954,G__G__Geom1_105_0_42, 103, -1, G__defined_typename("Bool_t"), 0, 6, 3, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"d - 'Double_t' 0 - cphi d - 'Double_t' 0 - sphi "
"d - 'Double_t' 1 - snext d - 'Double_t' 1 - rxy", (char*)NULL, (void*) G__func2void( (Bool_t (*)(Double_t*, Double_t*, Double_t, Double_t, Double_t&, Double_t&))(&TGeoShape::IsCrossingSemiplane) ), 0);
   G__memfunc_setup("IsSameWithinTolerance",2130,G__G__Geom1_105_0_43, 103, -1, G__defined_typename("Bool_t"), 0, 2, 3, 1, 0, 
"d - 'Double_t' 0 - a d - 'Double_t' 0 - b", (char*)NULL, (void*) G__func2void( (Bool_t (*)(Double_t, Double_t))(&TGeoShape::IsSameWithinTolerance) ), 0);
   G__memfunc_setup("IsSegCrossing",1315,G__G__Geom1_105_0_44, 103, -1, G__defined_typename("Bool_t"), 0, 8, 3, 1, 0, 
"d - 'Double_t' 0 - x1 d - 'Double_t' 0 - y1 "
"d - 'Double_t' 0 - x2 d - 'Double_t' 0 - y2 "
"d - 'Double_t' 0 - x3 d - 'Double_t' 0 - y3 "
"d - 'Double_t' 0 - x4 d - 'Double_t' 0 - y4", (char*)NULL, (void*) G__func2void( (Bool_t (*)(Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t))(&TGeoShape::IsSegCrossing) ), 0);
   G__memfunc_setup("IsInPhiRange",1153,G__G__Geom1_105_0_45, 103, -1, G__defined_typename("Bool_t"), 0, 3, 3, 1, 0, 
"D - 'Double_t' 0 - point d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - phi2", (char*)NULL, (void*) G__func2void( (Bool_t (*)(Double_t*, Double_t, Double_t))(&TGeoShape::IsInPhiRange) ), 0);
   G__memfunc_setup("IsReflected",1098,G__G__Geom1_105_0_46, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsRunTimeShape",1393,G__G__Geom1_105_0_47, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Geom1_105_0_48, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValidBox",981,G__G__Geom1_105_0_49, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_105_0_50, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("MakeBuffer3D",1103,G__G__Geom1_105_0_51, 85, G__get_linked_tagnum(&G__G__Geom1LN_TBuffer3D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NormalPhi",906,G__G__Geom1_105_0_52, 121, -1, -1, 0, 7, 3, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm d - 'Double_t' 0 - c1 "
"d - 'Double_t' 0 - s1 d - 'Double_t' 0 - c2 "
"d - 'Double_t' 0 - s2", (char*)NULL, (void*) G__func2void( (void (*)(Double_t*, Double_t*, Double_t*, Double_t, Double_t, Double_t, Double_t))(&TGeoShape::NormalPhi) ), 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("Safety",620,G__G__Geom1_105_0_54, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SafetyPhi",909,G__G__Geom1_105_0_55, 100, -1, G__defined_typename("Double_t"), 0, 4, 3, 1, 0, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 - in "
"d - 'Double_t' 0 - phi1 d - 'Double_t' 0 - phi2", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t*, Bool_t, Double_t, Double_t))(&TGeoShape::SafetyPhi) ), 0);
   G__memfunc_setup("SetDimensions",1349,G__G__Geom1_105_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetId",473,G__G__Geom1_105_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_105_0_58, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_105_0_59, 121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetSegsAndPols",1391,G__G__Geom1_105_0_60, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TBuffer3D' - 1 - buff", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetRuntime",1040,G__G__Geom1_105_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShapeDistancetoPrimitive",2488,G__G__Geom1_105_0_62, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - numpoints i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_105_0_63, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetShapeBit",1084,G__G__Geom1_105_0_64, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - f g - 'Bool_t' 0 - set", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShapeBit",1084,G__G__Geom1_105_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetShapeBit",1299,G__G__Geom1_105_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TestShapeBit",1200,G__G__Geom1_105_0_67, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TestShapeBits",1315,G__G__Geom1_105_0_68, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InvertShapeBit",1416,G__G__Geom1_105_0_69, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_105_0_70, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoShape::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_105_0_71, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoShape::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_105_0_72, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoShape::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_105_0_73, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoShape::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_105_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_105_0_78, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoShape::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_105_0_79, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoShape::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_105_0_80, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoShape::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_105_0_81, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoShape::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoShape", 990, G__G__Geom1_105_0_82, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_105_0_83, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 1, 1, 1, 1, 0, "u 'TGeoShape' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoMatrix(void) {
   /* TGeoMatrix */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix));
   G__memfunc_setup("operator=",937,G__G__Geom1_106_0_4, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 1, 1, 1, 1, 0, "u 'TGeoMatrix' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__Geom1_106_0_5, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 1, 1, 1, 1, 8, "u 'TGeoMatrix' - 11 - right", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Geom1_106_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TGeoMatrix' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsIdentity",1030,G__G__Geom1_106_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsTranslation",1355,G__G__Geom1_106_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRotation",1036,G__G__Geom1_106_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsReflection",1223,G__G__Geom1_106_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsScale",676,G__G__Geom1_106_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCombi",678,G__G__Geom1_106_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsGeneral",890,G__G__Geom1_106_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRegistered",1226,G__G__Geom1_106_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRotAboutZ",1094,G__G__Geom1_106_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHomogenousMatrix",1977,G__G__Geom1_106_0_16, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - hmat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPointerName",1410,G__G__Geom1_106_0_17, 67, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetByteCount",1213,G__G__Geom1_106_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTranslation",1455,G__G__Geom1_106_0_19, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetRotationMatrix",1765,G__G__Geom1_106_0_20, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetScale",776,G__G__Geom1_106_0_21, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Inverse",732,G__G__Geom1_106_0_22, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("LocalToMaster",1306,G__G__Geom1_106_0_23, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LocalToMasterVect",1708,G__G__Geom1_106_0_24, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LocalToMasterBomb",1690,G__G__Geom1_106_0_25, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClone",879,G__G__Geom1_106_0_26, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("MasterToLocal",1306,G__G__Geom1_106_0_27, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MasterToLocalVect",1708,G__G__Geom1_106_0_28, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MasterToLocalBomb",1690,G__G__Geom1_106_0_29, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Normalize",945,G__G__Geom1_106_0_30, 121, -1, -1, 0, 1, 3, 1, 0, "D - 'Double_t' 0 - vect", (char*)NULL, (void*) G__func2void( (void (*)(Double_t*))(&TGeoMatrix::Normalize) ), 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("RotateX",711,G__G__Geom1_106_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RotateY",712,G__G__Geom1_106_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RotateZ",713,G__G__Geom1_106_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReflectX",797,G__G__Geom1_106_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - leftside g - 'Bool_t' 0 'kFALSE' rotonly", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReflectY",798,G__G__Geom1_106_0_36, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - leftside g - 'Bool_t' 0 'kFALSE' rotonly", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReflectZ",799,G__G__Geom1_106_0_37, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - leftside g - 'Bool_t' 0 'kFALSE' rotonly", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RegisterYourself",1694,G__G__Geom1_106_0_38, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDefaultName",1394,G__G__Geom1_106_0_39, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDx",488,G__G__Geom1_106_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDy",489,G__G__Geom1_106_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDz",490,G__G__Geom1_106_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_106_0_43, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoMatrix::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_106_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMatrix::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_106_0_45, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoMatrix::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_106_0_46, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoMatrix::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_106_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_106_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMatrix::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_106_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMatrix::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_106_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMatrix::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_106_0_54, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMatrix::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoMatrix", 1122, G__G__Geom1_106_0_55, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoHMatrix(void) {
   /* TGeoHMatrix */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix));
   G__memfunc_setup("TGeoHMatrix",1068,G__G__Geom1_107_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoHMatrix",1068,G__G__Geom1_107_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 0, 1, 1, 1, 0, "u 'TGeoMatrix' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoHMatrix",1068,G__G__Geom1_107_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Geom1_107_0_4, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 1, 1, 1, 1, 0, "U 'TGeoMatrix' - 10 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Geom1_107_0_5, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 1, 1, 1, 1, 0, "u 'TGeoMatrix' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Geom1_107_0_6, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 1, 1, 1, 1, 0, "u 'TGeoHMatrix' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Geom1_107_0_7, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 1, 1, 1, 1, 0, "u 'TGeoMatrix' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CopyFrom",815,G__G__Geom1_107_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoMatrix' - 10 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Determinant",1147,G__G__Geom1_107_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Inverse",732,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClone",879,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Multiply",864,G__G__Geom1_107_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoMatrix' - 10 - right", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultiplyLeft",1259,G__G__Geom1_107_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoMatrix' - 10 - left", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RotateX",711,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RotateY",712,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RotateZ",713,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReflectX",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - leftside g - 'Bool_t' 0 'kFALSE' rotonly", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReflectY",798,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - leftside g - 'Bool_t' 0 'kFALSE' rotonly", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReflectZ",799,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - leftside g - 'Bool_t' 0 'kFALSE' rotonly", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDx",488,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDy",489,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dy", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDz",490,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTranslation",1467,G__G__Geom1_107_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - vect", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRotation",1148,G__G__Geom1_107_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScale",788,G__G__Geom1_107_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTranslation",1455,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRotationMatrix",1765,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetScale",776,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTranslation",1455,G__G__Geom1_107_0_31, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRotationMatrix",1765,G__G__Geom1_107_0_32, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetScale",776,G__G__Geom1_107_0_33, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_107_0_34, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoHMatrix::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_107_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHMatrix::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_107_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoHMatrix::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_107_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoHMatrix::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_107_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__Geom1_107_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHMatrix::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_107_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoHMatrix::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_107_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHMatrix::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_107_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoHMatrix::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoHMatrix", 1068, G__G__Geom1_107_0_46, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 0, 1, 1, 1, 0, "u 'TGeoHMatrix' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoHMatrix", 1194, G__G__Geom1_107_0_47, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoBoolNode(void) {
   /* TGeoBoolNode */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNode));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNode), -1, 1, 1, 1, 4, 0, "u 'TGeoBoolNode' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("MakeBranch",972,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"C - - 10 - expr g - 'Bool_t' 0 - left", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeBBox",1096,G__G__Geom1_108_0_7, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 1 - dx d - 'Double_t' 1 - dy "
"d - 'Double_t' 1 - dz D - 'Double_t' 0 - origin", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ComputeNormal",1350,G__G__Geom1_108_0_8, 121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Contains",831,G__G__Geom1_108_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DistanceToPrimitive",1959,G__G__Geom1_108_0_10, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DistFromInside",1412,G__G__Geom1_108_0_11, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 '0' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DistFromOutside",1541,G__G__Geom1_108_0_12, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 '0' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetBooleanOperator",1836,G__G__Geom1_108_0_13, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNodecLcLEGeoBoolType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetNpoints",1035,G__G__Geom1_108_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetLeftMatrix",1312,G__G__Geom1_108_0_15, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRightMatrix",1427,G__G__Geom1_108_0_16, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLeftShape",1180,G__G__Geom1_108_0_17, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRightShape",1295,G__G__Geom1_108_0_18, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 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("RegisterMatrices",1661,G__G__Geom1_108_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Safety",620,G__G__Geom1_108_0_21, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_108_0_23, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,G__G__Geom1_108_0_24, 121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSelected",1109,G__G__Geom1_108_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - sel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sizeof3D",743,G__G__Geom1_108_0_26, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_108_0_27, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoBoolNode::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_108_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBoolNode::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_108_0_29, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoBoolNode::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_108_0_30, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoBoolNode::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_108_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_108_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBoolNode::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_108_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoBoolNode::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_108_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBoolNode::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_108_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoBoolNode::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoBoolNode", 1279, G__G__Geom1_108_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoUnion(void) {
   /* TGeoUnion */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoUnion));
   G__memfunc_setup("TGeoUnion",888,G__G__Geom1_110_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoUnion), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoUnion",888,G__G__Geom1_110_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoUnion), -1, 0, 2, 1, 1, 0, 
"C - - 10 - expr1 C - - 10 - expr2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoUnion",888,G__G__Geom1_110_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoUnion), -1, 0, 4, 1, 1, 0, 
"U 'TGeoShape' - 0 - left U 'TGeoShape' - 0 - right "
"U 'TGeoMatrix' - 0 '0' lmat U 'TGeoMatrix' - 0 '0' rmat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 1 - dx d - 'Double_t' 1 - dy "
"d - 'Double_t' 1 - dz D - 'Double_t' 0 - origin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistanceToPrimitive",1959,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 '0' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 '0' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBooleanOperator",1836,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNodecLcLEGeoBoolType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNpoints",1035,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (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__Geom1_110_0_16, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoUnion::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_110_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoUnion::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_110_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoUnion::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_110_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoUnion::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_110_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__Geom1_110_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoUnion::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_110_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoUnion::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_110_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoUnion::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_110_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoUnion::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoUnion", 1014, G__G__Geom1_110_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoIntersection(void) {
   /* TGeoIntersection */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIntersection));
   G__memfunc_setup("TGeoIntersection",1638,G__G__Geom1_111_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoIntersection), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoIntersection",1638,G__G__Geom1_111_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoIntersection), -1, 0, 2, 1, 1, 0, 
"C - - 10 - expr1 C - - 10 - expr2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoIntersection",1638,G__G__Geom1_111_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoIntersection), -1, 0, 4, 1, 1, 0, 
"U 'TGeoShape' - 0 - left U 'TGeoShape' - 0 - right "
"U 'TGeoMatrix' - 0 '0' lmat U 'TGeoMatrix' - 0 '0' rmat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 1 - dx d - 'Double_t' 1 - dy "
"d - 'Double_t' 1 - dz D - 'Double_t' 0 - origin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistanceToPrimitive",1959,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 '0' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 '0' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBooleanOperator",1836,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNodecLcLEGeoBoolType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNpoints",1035,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (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__Geom1_111_0_16, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoIntersection::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_111_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoIntersection::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_111_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoIntersection::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_111_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoIntersection::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_111_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__Geom1_111_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoIntersection::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_111_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoIntersection::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_111_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoIntersection::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_111_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoIntersection::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoIntersection", 1764, G__G__Geom1_111_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoSubtraction(void) {
   /* TGeoSubtraction */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoSubtraction));
   G__memfunc_setup("TGeoSubtraction",1533,G__G__Geom1_112_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoSubtraction), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoSubtraction",1533,G__G__Geom1_112_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoSubtraction), -1, 0, 2, 1, 1, 0, 
"C - - 10 - expr1 C - - 10 - expr2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoSubtraction",1533,G__G__Geom1_112_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoSubtraction), -1, 0, 4, 1, 1, 0, 
"U 'TGeoShape' - 0 - left U 'TGeoShape' - 0 - right "
"U 'TGeoMatrix' - 0 '0' lmat U 'TGeoMatrix' - 0 '0' rmat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeBBox",1096,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 1 - dx d - 'Double_t' 1 - dy "
"d - 'Double_t' 1 - dz D - 'Double_t' 0 - origin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistanceToPrimitive",1959,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 '0' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 '0' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBooleanOperator",1836,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNodecLcLEGeoBoolType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNpoints",1035,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (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__Geom1_112_0_16, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoSubtraction::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_112_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoSubtraction::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_112_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoSubtraction::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_112_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoSubtraction::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_112_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__Geom1_112_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoSubtraction::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_112_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoSubtraction::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_112_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoSubtraction::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_112_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoSubtraction::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoSubtraction", 1659, G__G__Geom1_112_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoElementTable(void) {
   /* TGeoElementTable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable));
   G__memfunc_setup("TGeoElementTable",1569,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable), -1, 0, 1, 1, 2, 0, "u 'TGeoElementTable' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable), -1, 1, 1, 1, 2, 0, "u 'TGeoElementTable' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoElementTable",1569,G__G__Geom1_137_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoElementTable",1569,G__G__Geom1_137_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nelements", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddElement",979,G__G__Geom1_137_0_5, 121, -1, -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - z d - 'Double_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddElement",979,G__G__Geom1_137_0_6, 121, -1, -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - z i - 'Int_t' 0 - n "
"d - 'Double_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddElementRN",1139,G__G__Geom1_137_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoElementRN' - 0 - elem", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddIsotope",1004,G__G__Geom1_137_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoIsotope' - 0 - isotope", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildDefaultElements",2034,G__G__Geom1_137_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ImportElementsRN",1624,G__G__Geom1_137_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckTable",966,G__G__Geom1_137_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindElement",1099,G__G__Geom1_137_0_12, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindIsotope",1124,G__G__Geom1_137_0_13, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoIsotope), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetElement",1002,G__G__Geom1_137_0_14, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetElementRN",1162,G__G__Geom1_137_0_15, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - ENDFcode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetElementRN",1162,G__G__Geom1_137_0_16, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN), -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - a i - 'Int_t' 0 - z "
"i - 'Int_t' 0 '0' iso", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetElementsRN",1277,G__G__Geom1_137_0_17, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasDefaultElements",1822,G__G__Geom1_137_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasRNElements",1273,G__G__Geom1_137_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNelements",1227,G__G__Geom1_137_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNelementsRN",1387,G__G__Geom1_137_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExportElementsRN",1631,G__G__Geom1_137_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_137_0_23, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoElementTable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_137_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoElementTable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_137_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoElementTable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_137_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoElementTable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_137_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__Geom1_137_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoElementTable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_137_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoElementTable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_137_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoElementTable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_137_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoElementTable::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoElementTable", 1695, G__G__Geom1_137_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoIsotope(void) {
   /* TGeoIsotope */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIsotope));
   G__memfunc_setup("TGeoIsotope",1106,G__G__Geom1_138_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoIsotope), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoIsotope",1106,G__G__Geom1_138_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoIsotope), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - z "
"i - 'Int_t' 0 - n d - 'Double_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZ",378,G__G__Geom1_138_0_3, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetN",366,G__G__Geom1_138_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetA",353,G__G__Geom1_138_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindIsotope",1124,G__G__Geom1_138_0_6, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoIsotope), -1, 0, 1, 3, 1, 0, "C - - 10 - name", (char*)NULL, (void*) G__func2void( (TGeoIsotope* (*)(const char*))(&TGeoIsotope::FindIsotope) ), 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_138_0_8, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoIsotope::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_138_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoIsotope::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_138_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoIsotope::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_138_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoIsotope::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_138_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__Geom1_138_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoIsotope::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_138_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoIsotope::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_138_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoIsotope::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_138_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoIsotope::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoIsotope", 1106, G__G__Geom1_138_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoIsotope), -1, 0, 1, 1, 1, 0, "u 'TGeoIsotope' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoIsotope", 1232, G__G__Geom1_138_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_138_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoIsotope), -1, 1, 1, 1, 1, 0, "u 'TGeoIsotope' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoElement(void) {
   /* TGeoElement */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement));
   G__memfunc_setup("TGeoElement",1081,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement), -1, 0, 1, 1, 4, 0, "u 'TGeoElement' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement), -1, 1, 1, 1, 4, 0, "u 'TGeoElement' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoElement",1081,G__G__Geom1_139_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoElement",1081,G__G__Geom1_139_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - z d - 'Double_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoElement",1081,G__G__Geom1_139_0_5, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - nisotopes", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoElement",1081,G__G__Geom1_139_0_6, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - title "
"i - 'Int_t' 0 - z i - 'Int_t' 0 - n "
"d - 'Double_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ENDFCode",664,G__G__Geom1_139_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Z",90,G__G__Geom1_139_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("N",78,G__G__Geom1_139_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Neff",383,G__G__Geom1_139_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("A",65,G__G__Geom1_139_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddIsotope",1004,G__G__Geom1_139_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGeoIsotope' - 0 - isotope d - 'Double_t' 0 - relativeAbundance", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNisotopes",1252,G__G__Geom1_139_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIsotope",1027,G__G__Geom1_139_0_14, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoIsotope), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRelativeAbundance",2013,G__G__Geom1_139_0_15, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasIsotopes",1138,G__G__Geom1_139_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDefined",875,G__G__Geom1_139_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRadioNuclide",1391,G__G__Geom1_139_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsUsed",589,G__G__Geom1_139_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDefined",987,G__G__Geom1_139_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUsed",701,G__G__Geom1_139_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetElementTable",1490,G__G__Geom1_139_0_23, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TGeoElementTable* (*)())(&TGeoElement::GetElementTable) ), 0);
   G__memfunc_setup("Class",502,G__G__Geom1_139_0_24, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoElement::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_139_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoElement::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_139_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoElement::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_139_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoElement::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_139_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__Geom1_139_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoElement::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_139_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoElement::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_139_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoElement::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_139_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoElement::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoElement", 1207, G__G__Geom1_139_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoDecayChannel(void) {
   /* TGeoDecayChannel */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannel));
   G__memfunc_setup("TGeoDecayChannel",1550,G__G__Geom1_141_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannel), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoDecayChannel",1550,G__G__Geom1_141_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannel), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - decay i - 'Int_t' 0 - diso "
"d - 'Double_t' 0 - branchingRatio d - 'Double_t' 0 - qValue", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoDecayChannel",1550,G__G__Geom1_141_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannel), -1, 0, 1, 1, 1, 0, "u 'TGeoDecayChannel' - 11 - dc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Geom1_141_0_4, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannel), -1, 1, 1, 1, 1, 0, "u 'TGeoDecayChannel' - 11 - dc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIndex",792,G__G__Geom1_141_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Decay",486,G__G__Geom1_141_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BranchingRatio",1419,G__G__Geom1_141_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Qvalue",622,G__G__Geom1_141_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeltaIso",789,G__G__Geom1_141_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Daughter",820,G__G__Geom1_141_0_11, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Parent",618,G__G__Geom1_141_0_12, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DecayName",871,G__G__Geom1_141_0_13, 121, -1, -1, 0, 2, 3, 1, 0, 
"h - 'UInt_t' 0 - decay u 'TString' - 1 - name", (char*)NULL, (void*) G__func2void( (void (*)(UInt_t, TString&))(&TGeoDecayChannel::DecayName) ), 0);
   G__memfunc_setup("SetParent",918,G__G__Geom1_141_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoElementRN' - 0 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDaughter",1120,G__G__Geom1_141_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoElementRN' - 0 - daughter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\" \"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadDecay",866,G__G__Geom1_141_0_17, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoDecayChannel), -1, 0, 1, 3, 1, 0, "C - - 10 - record", (char*)NULL, (void*) G__func2void( (TGeoDecayChannel* (*)(const char*))(&TGeoDecayChannel::ReadDecay) ), 0);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DecayShift",996,G__G__Geom1_141_0_19, 121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - dA i - 'Int_t' 1 - dZ "
"i - 'Int_t' 1 - dI", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_141_0_20, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoDecayChannel::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_141_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoDecayChannel::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_141_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoDecayChannel::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_141_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoDecayChannel::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_141_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__Geom1_141_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoDecayChannel::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_141_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoDecayChannel::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_141_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoDecayChannel::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_141_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoDecayChannel::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoDecayChannel", 1676, G__G__Geom1_141_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoBatemanSol(void) {
   /* TGeoBatemanSol */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol));
   G__memfunc_setup("TGeoBatemanSol",1365,G__G__Geom1_142_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoBatemanSol",1365,G__G__Geom1_142_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol), -1, 0, 1, 1, 1, 0, "U 'TGeoElementRN' - 0 - elem", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoBatemanSol",1365,G__G__Geom1_142_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol), -1, 0, 1, 1, 1, 0, "U 'TObjArray' - 10 - chain", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoBatemanSol",1365,G__G__Geom1_142_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol), -1, 0, 1, 1, 1, 0, "u 'TGeoBatemanSol' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Geom1_142_0_5, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol), -1, 1, 1, 1, 1, 0, "u 'TGeoBatemanSol' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Geom1_142_0_6, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol), -1, 1, 1, 1, 1, 0, "u 'TGeoBatemanSol' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Concentration",1367,G__G__Geom1_142_0_7, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - time", (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("GetCoeff",771,G__G__Geom1_142_0_9, 121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - i d - 'Double_t' 1 - cn "
"d - 'Double_t' 1 - lambda", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRange",781,G__G__Geom1_142_0_10, 121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - tmin d - 'Double_t' 1 - tmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetElement",1002,G__G__Geom1_142_0_11, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTopElement",1309,G__G__Geom1_142_0_12, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNcoeff",881,G__G__Geom1_142_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRange",793,G__G__Geom1_142_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '0.' tmin d - 'Double_t' 0 '0.' tmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFactor",907,G__G__Geom1_142_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - factor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindSolution",1246,G__G__Geom1_142_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObjArray' - 10 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Normalize",945,G__G__Geom1_142_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - factor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_142_0_19, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoBatemanSol::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_142_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBatemanSol::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_142_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoBatemanSol::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_142_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoBatemanSol::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_142_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_142_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBatemanSol::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_142_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoBatemanSol::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_142_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBatemanSol::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_142_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoBatemanSol::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoBatemanSol", 1491, G__G__Geom1_142_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoElementRN(void) {
   /* TGeoElementRN */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN));
   G__memfunc_setup("MakeName",767,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - a i - 'Int_t' 0 - z "
"i - 'Int_t' 0 - iso", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoElementRN",1241,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN), -1, 0, 1, 1, 4, 0, "u 'TGeoElementRN' - 11 - elem", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN), -1, 1, 1, 1, 4, 0, "u 'TGeoElementRN' - 11 - elem", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoElementRN",1241,G__G__Geom1_143_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoElementRN",1241,G__G__Geom1_143_0_5, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN), -1, 0, 13, 1, 1, 0, 
"i - 'Int_t' 0 - A i - 'Int_t' 0 - Z "
"i - 'Int_t' 0 - iso d - 'Double_t' 0 - level "
"d - 'Double_t' 0 - deltaM d - 'Double_t' 0 - halfLife "
"C - - 10 - JP d - 'Double_t' 0 - natAbun "
"d - 'Double_t' 0 - th_f d - 'Double_t' 0 - tg_f "
"d - 'Double_t' 0 - th_s d - 'Double_t' 0 - tg_s "
"i - 'Int_t' 0 - status", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddDecay",751,G__G__Geom1_143_0_6, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - decay i - 'Int_t' 0 - diso "
"d - 'Double_t' 0 - branchingRatio d - 'Double_t' 0 - qValue", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddDecay",751,G__G__Geom1_143_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoDecayChannel' - 0 - dc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRatio",776,G__G__Geom1_143_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGeoBatemanSol' - 1 - ratio", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetRatio",1026,G__G__Geom1_143_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ENDF",285,G__G__Geom1_143_0_10, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
"i - 'Int_t' 0 - a i - 'Int_t' 0 - z "
"i - 'Int_t' 0 - iso", (char*)NULL, (void*) G__func2void( (Int_t (*)(Int_t, Int_t, Int_t))(&TGeoElementRN::ENDF) ), 0);
   G__memfunc_setup("ENDFCode",664,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsRadioNuclide",1391,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MassNo",593,G__G__Geom1_143_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AtomicNo",794,G__G__Geom1_143_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsoNo",488,G__G__Geom1_143_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Level",504,G__G__Geom1_143_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MassEx",593,G__G__Geom1_143_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HalfLife",763,G__G__Geom1_143_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NatAbun",681,G__G__Geom1_143_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PJ",154,G__G__Geom1_143_0_20, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH_F",321,G__G__Geom1_143_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TG_F",320,G__G__Geom1_143_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TH_S",334,G__G__Geom1_143_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TG_S",333,G__G__Geom1_143_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Status",644,G__G__Geom1_143_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Stable",603,G__G__Geom1_143_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Decays",601,G__G__Geom1_143_0_27, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNdecays",999,G__G__Geom1_143_0_28, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Ratio",511,G__G__Geom1_143_0_29, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBatemanSol), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckDecays",1079,G__G__Geom1_143_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DecayResult",1125,G__G__Geom1_143_0_31, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TGeoDecayChannel' - 0 - dc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillPopulation",1458,G__G__Geom1_143_0_32, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TObjArray' - 0 - population d - 'Double_t' 0 '0.001' precision "
"d - 'Double_t' 0 '1.' factor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadElementRN",1254,G__G__Geom1_143_0_34, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN), -1, 0, 2, 3, 1, 0, 
"C - - 10 - record i - 'Int_t' 1 - ndecays", (char*)NULL, (void*) G__func2void( (TGeoElementRN* (*)(const char*, Int_t&))(&TGeoElementRN::ReadElementRN) ), 0);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_143_0_36, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoElementRN::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_143_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoElementRN::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_143_0_38, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoElementRN::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_143_0_39, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoElementRN::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_143_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_143_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoElementRN::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_143_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoElementRN::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_143_0_46, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoElementRN::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_143_0_47, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoElementRN::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoElementRN", 1367, G__G__Geom1_143_0_48, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoElemIter(void) {
   /* TGeoElemIter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoElemIter));
   G__memfunc_setup("TGeoElemIter",1158,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElemIter), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Down",408,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN), -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - ibranch", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Up",197,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoElemIter",1158,G__G__Geom1_146_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElemIter), -1, 0, 2, 1, 1, 0, 
"U 'TGeoElementRN' - 0 - top d - 'Double_t' 0 '1.e-4' limit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoElemIter",1158,G__G__Geom1_146_0_5, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElemIter), -1, 0, 1, 1, 1, 0, "u 'TGeoElemIter' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Geom1_146_0_6, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElemIter), -1, 1, 1, 1, 1, 0, "u 'TGeoElemIter' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Geom1_146_0_7, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Next",415,G__G__Geom1_146_0_8, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBranch",878,G__G__Geom1_146_0_9, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTop",595,G__G__Geom1_146_0_10, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetElement",1002,G__G__Geom1_146_0_11, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementRN), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLevel",792,G__G__Geom1_146_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRatio",799,G__G__Geom1_146_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__G__Geom1_146_0_14, 121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLimitRatio",1322,G__G__Geom1_146_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - limit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_146_0_16, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoElemIter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_146_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoElemIter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_146_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoElemIter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_146_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoElemIter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Geom1_146_0_20, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Geom1_146_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_146_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_146_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__Geom1_146_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoElemIter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_146_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoElemIter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_146_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoElemIter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_146_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoElemIter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoElemIter", 1284, G__G__Geom1_146_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoMaterial(void) {
   /* TGeoMaterial */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial));
   G__memfunc_setup("TGeoMaterial",1182,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 1, 1, 2, 0, "u 'TGeoMaterial' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 1, 1, 1, 2, 0, "u 'TGeoMaterial' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoMaterial",1182,G__G__Geom1_157_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoMaterial",1182,G__G__Geom1_157_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoMaterial",1182,G__G__Geom1_157_0_5, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - a "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - rho "
"d - 'Double_t' 0 '0' radlen d - 'Double_t' 0 '0' intlen", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoMaterial",1182,G__G__Geom1_157_0_6, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - a "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - rho "
"i 'TGeoMaterial::EGeoMaterialState' - 0 - state d - 'Double_t' 0 'STP_temperature' temperature "
"d - 'Double_t' 0 'STP_pressure' pressure", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoMaterial",1182,G__G__Geom1_157_0_7, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name U 'TGeoElement' - 0 - elem "
"d - 'Double_t' 0 - rho", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Coulomb",721,G__G__Geom1_157_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 3, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t))(&TGeoMaterial::Coulomb) ), 0);
   G__memfunc_setup("DecayMaterial",1301,G__G__Geom1_157_0_9, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - time d - 'Double_t' 0 '0.001' precision", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillMaterialEvolution",2171,G__G__Geom1_157_0_10, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObjArray' - 0 - population d - 'Double_t' 0 '0.001' precision", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetByteCount",1213,G__G__Geom1_157_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetA",353,G__G__Geom1_157_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetZ",378,G__G__Geom1_157_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDefaultColor",1508,G__G__Geom1_157_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDensity",1024,G__G__Geom1_157_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetElement",1002,G__G__Geom1_157_0_16, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBaseElement",1381,G__G__Geom1_157_0_17, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPointerName",1410,G__G__Geom1_157_0_18, 67, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRadLen",854,G__G__Geom1_157_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIntLen",874,G__G__Geom1_157_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIndex",792,G__G__Geom1_157_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCerenkovProperties",2186,G__G__Geom1_157_0_22, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTransparency",1562,G__G__Geom1_157_0_23, 99, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTemperature",1454,G__G__Geom1_157_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPressure",1145,G__G__Geom1_157_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetState",801,G__G__Geom1_157_0_26, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterialState), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEq",370,G__G__Geom1_157_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TGeoMaterial' - 10 - other", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsUsed",589,G__G__Geom1_157_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsMixture",938,G__G__Geom1_157_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetA",365,G__G__Geom1_157_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZ",390,G__G__Geom1_157_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDensity",1036,G__G__Geom1_157_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - density", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIndex",804,G__G__Geom1_157_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCerenkovProperties",2198,G__G__Geom1_157_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - cerenkov", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRadLen",866,G__G__Geom1_157_0_37, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - radlen d - 'Double_t' 0 '0.' intlen", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUsed",701,G__G__Geom1_157_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTransparency",1574,G__G__Geom1_157_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 '0' transparency", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTemperature",1466,G__G__Geom1_157_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - temperature", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPressure",1157,G__G__Geom1_157_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - pressure", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetState",813,G__G__Geom1_157_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TGeoMaterial::EGeoMaterialState' - 0 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ScreenFactor",1215,G__G__Geom1_157_0_43, 100, -1, G__defined_typename("Double_t"), 0, 1, 3, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t))(&TGeoMaterial::ScreenFactor) ), 0);
   G__memfunc_setup("Class",502,G__G__Geom1_157_0_44, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoMaterial::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_157_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMaterial::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_157_0_46, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoMaterial::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_157_0_47, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoMaterial::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_157_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_157_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMaterial::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_157_0_53, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMaterial::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_157_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMaterial::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_157_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMaterial::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoMaterial", 1308, G__G__Geom1_157_0_56, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoMixture(void) {
   /* TGeoMixture */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture));
   G__memfunc_setup("TGeoMixture",1117,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture), -1, 0, 1, 1, 2, 0, "u 'TGeoMixture' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture), -1, 1, 1, 1, 2, 0, "u 'TGeoMixture' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("AverageProperties",1768,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoMixture",1117,G__G__Geom1_160_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoMixture",1117,G__G__Geom1_160_0_5, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMixture), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - nel "
"d - 'Double_t' 0 '-1' rho", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddElement",979,G__G__Geom1_160_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - a d - 'Double_t' 0 - z "
"d - 'Double_t' 0 - weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddElement",979,G__G__Geom1_160_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGeoMaterial' - 0 - mat d - 'Double_t' 0 - weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddElement",979,G__G__Geom1_160_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGeoElement' - 0 - elem d - 'Double_t' 0 - weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddElement",979,G__G__Geom1_160_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGeoElement' - 0 - elem i - 'Int_t' 0 - natoms", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineElement",1301,G__G__Geom1_160_0_10, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - iel d - 'Double_t' 0 - a "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineElement",1301,G__G__Geom1_160_0_11, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - iel U 'TGeoElement' - 0 - elem "
"d - 'Double_t' 0 - weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineElement",1301,G__G__Geom1_160_0_12, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - iel i - 'Int_t' 0 - z "
"i - 'Int_t' 0 - natoms", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DecayMaterial",1301,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - time d - 'Double_t' 0 '0.001' precision", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillMaterialEvolution",2171,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObjArray' - 0 - population d - 'Double_t' 0 '0.001' precision", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetByteCount",1213,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetElement",1002,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElement), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNelements",1227,G__G__Geom1_160_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZmixt",828,G__G__Geom1_160_0_18, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAmixt",803,G__G__Geom1_160_0_19, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWmixt",825,G__G__Geom1_160_0_20, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNmixt",816,G__G__Geom1_160_0_21, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEq",370,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TGeoMaterial' - 10 - other", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsMixture",938,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetA",365,G__G__Geom1_160_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetZ",390,G__G__Geom1_160_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_160_0_28, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoMixture::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_160_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMixture::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_160_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoMixture::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_160_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoMixture::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_160_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_160_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMixture::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_160_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMixture::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_160_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMixture::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_160_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMixture::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoMixture", 1243, G__G__Geom1_160_0_40, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoMedium(void) {
   /* TGeoMedium */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium));
   G__memfunc_setup("TGeoMedium",976,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium), -1, 0, 1, 1, 2, 0, "u 'TGeoMedium' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium), -1, 1, 1, 1, 2, 0, "u 'TGeoMedium' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoMedium",976,G__G__Geom1_161_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoMedium",976,G__G__Geom1_161_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - numed "
"U 'TGeoMaterial' - 10 - mat D - 'Double_t' 0 '0' params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoMedium",976,G__G__Geom1_161_0_5, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium), -1, 0, 11, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - numed "
"i - 'Int_t' 0 - imat i - 'Int_t' 0 - isvol "
"i - 'Int_t' 0 - ifield d - 'Double_t' 0 - fieldm "
"d - 'Double_t' 0 - tmaxfd d - 'Double_t' 0 - stemax "
"d - 'Double_t' 0 - deemax d - 'Double_t' 0 - epsil "
"d - 'Double_t' 0 - stmin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetByteCount",1213,G__G__Geom1_161_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetId",461,G__G__Geom1_161_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParam",785,G__G__Geom1_161_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParam",797,G__G__Geom1_161_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - i d - 'Double_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPointerName",1410,G__G__Geom1_161_0_10, 67, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaterial",1103,G__G__Geom1_161_0_11, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetId",473,G__G__Geom1_161_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaterial",1115,G__G__Geom1_161_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoMaterial' - 0 - mat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCerenkovProperties",2198,G__G__Geom1_161_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - cerenkov", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_161_0_16, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoMedium::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_161_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMedium::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_161_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoMedium::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_161_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoMedium::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_161_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__Geom1_161_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMedium::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_161_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMedium::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_161_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMedium::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_161_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMedium::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoMedium", 1102, G__G__Geom1_161_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoTranslation(void) {
   /* TGeoTranslation */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation));
   G__memfunc_setup("TGeoTranslation",1534,G__G__Geom1_164_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTranslation",1534,G__G__Geom1_164_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation), -1, 0, 1, 1, 1, 0, "u 'TGeoTranslation' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTranslation",1534,G__G__Geom1_164_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation), -1, 0, 1, 1, 1, 0, "u 'TGeoMatrix' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTranslation",1534,G__G__Geom1_164_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - dx d - 'Double_t' 0 - dy "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTranslation",1534,G__G__Geom1_164_0_5, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - dx "
"d - 'Double_t' 0 - dy d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Geom1_164_0_6, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation), -1, 1, 1, 1, 1, 0, "u 'TGeoMatrix' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Geom1_164_0_7, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTranslation), -1, 1, 1, 1, 1, 0, "u 'TGeoTranslation' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Geom1_164_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoTranslation' - 10 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Inverse",732,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LocalToMaster",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LocalToMasterVect",1708,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LocalToMasterBomb",1690,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClone",879,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MasterToLocal",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MasterToLocalVect",1708,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MasterToLocalBomb",1690,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RotateX",711,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RotateY",712,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RotateZ",713,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Subtract",840,G__G__Geom1_164_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoTranslation' - 10 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTranslation",1467,G__G__Geom1_164_0_22, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - dx d - 'Double_t' 0 - dy "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTranslation",1467,G__G__Geom1_164_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGeoMatrix' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDx",488,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDy",489,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dy", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDz",490,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTranslation",1455,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRotationMatrix",1765,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetScale",776,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_164_0_30, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTranslation::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_164_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTranslation::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_164_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTranslation::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_164_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTranslation::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_164_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__Geom1_164_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTranslation::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_164_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTranslation::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_164_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTranslation::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_164_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTranslation::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoTranslation", 1660, G__G__Geom1_164_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoRotation(void) {
   /* TGeoRotation */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation));
   G__memfunc_setup("CheckMatrix",1107,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoRotation",1215,G__G__Geom1_165_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoRotation",1215,G__G__Geom1_165_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation), -1, 0, 1, 1, 1, 0, "u 'TGeoRotation' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoRotation",1215,G__G__Geom1_165_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation), -1, 0, 1, 1, 1, 0, "u 'TGeoMatrix' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoRotation",1215,G__G__Geom1_165_0_5, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoRotation",1215,G__G__Geom1_165_0_6, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - phi "
"d - 'Double_t' 0 - theta d - 'Double_t' 0 - psi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoRotation",1215,G__G__Geom1_165_0_7, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - theta1 "
"d - 'Double_t' 0 - phi1 d - 'Double_t' 0 - theta2 "
"d - 'Double_t' 0 - phi2 d - 'Double_t' 0 - theta3 "
"d - 'Double_t' 0 - phi3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Geom1_165_0_8, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation), -1, 1, 1, 1, 1, 0, "u 'TGeoMatrix' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Geom1_165_0_9, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation), -1, 1, 1, 1, 1, 0, "u 'TGeoRotation' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Geom1_165_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Inverse",732,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Determinant",1147,G__G__Geom1_165_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FastRotZ",797,G__G__Geom1_165_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - sincos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAngles",890,G__G__Geom1_165_0_15, 121, -1, -1, 0, 6, 1, 1, 8, 
"d - 'Double_t' 1 - theta1 d - 'Double_t' 1 - phi1 "
"d - 'Double_t' 1 - theta2 d - 'Double_t' 1 - phi2 "
"d - 'Double_t' 1 - theta3 d - 'Double_t' 1 - phi3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAngles",890,G__G__Geom1_165_0_16, 121, -1, -1, 0, 3, 1, 1, 8, 
"d - 'Double_t' 1 - phi d - 'Double_t' 1 - theta "
"d - 'Double_t' 1 - psi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhiRotation",1425,G__G__Geom1_165_0_17, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "g - 'Bool_t' 0 'kFALSE' fixX", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LocalToMaster",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LocalToMasterVect",1708,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LocalToMasterBomb",1690,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClone",879,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MasterToLocal",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MasterToLocalVect",1708,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MasterToLocalBomb",1690,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MultiplyBy",1051,G__G__Geom1_165_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGeoRotation' - 0 - rot g - 'Bool_t' 0 'kTRUE' after", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RotateX",711,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RotateY",712,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RotateZ",713,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReflectX",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - leftside g - 'Bool_t' 0 'kFALSE' rotonly", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReflectY",798,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - leftside g - 'Bool_t' 0 'kFALSE' rotonly", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReflectZ",799,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - leftside g - 'Bool_t' 0 'kFALSE' rotonly", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetAngles",902,G__G__Geom1_165_0_33, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - phi d - 'Double_t' 0 - theta "
"d - 'Double_t' 0 - psi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAngles",902,G__G__Geom1_165_0_34, 121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - theta1 d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - theta2 d - 'Double_t' 0 - phi2 "
"d - 'Double_t' 0 - theta3 d - 'Double_t' 0 - phi3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMatrix",929,G__G__Geom1_165_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - rot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRotation",1148,G__G__Geom1_165_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGeoMatrix' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInverse",1020,G__G__Geom1_165_0_37, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - invmat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTranslation",1455,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRotationMatrix",1765,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetScale",776,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_165_0_41, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoRotation::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_165_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoRotation::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_165_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoRotation::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_165_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoRotation::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_165_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__Geom1_165_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoRotation::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_165_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoRotation::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_165_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoRotation::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_165_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoRotation::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoRotation", 1341, G__G__Geom1_165_0_53, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoScale(void) {
   /* TGeoScale */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale));
   G__memfunc_setup("TGeoScale",855,G__G__Geom1_166_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoScale",855,G__G__Geom1_166_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale), -1, 0, 1, 1, 1, 0, "u 'TGeoScale' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoScale",855,G__G__Geom1_166_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - sx d - 'Double_t' 0 - sy "
"d - 'Double_t' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoScale",855,G__G__Geom1_166_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - sx "
"d - 'Double_t' 0 - sy d - 'Double_t' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Inverse",732,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetScale",788,G__G__Geom1_166_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - sx d - 'Double_t' 0 - sy "
"d - 'Double_t' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LocalToMaster",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LocalToMaster",1306,G__G__Geom1_166_0_8, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 - dist D - 'Double_t' 10 '0' dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LocalToMasterVect",1708,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClone",879,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MasterToLocal",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MasterToLocal",1306,G__G__Geom1_166_0_12, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 - dist D - 'Double_t' 10 '0' dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MasterToLocalVect",1708,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReflectX",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - - g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReflectY",798,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - - g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReflectZ",799,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - - g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTranslation",1455,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRotationMatrix",1765,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetScale",776,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_166_0_20, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoScale::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_166_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoScale::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_166_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoScale::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_166_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoScale::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_166_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__Geom1_166_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoScale::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_166_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoScale::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_166_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoScale::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_166_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoScale::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoScale", 981, G__G__Geom1_166_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_166_0_33, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale), -1, 1, 1, 1, 1, 0, "u 'TGeoScale' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoCombiTrans(void) {
   /* TGeoCombiTrans */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans));
   G__memfunc_setup("TGeoCombiTrans",1377,G__G__Geom1_167_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoCombiTrans",1377,G__G__Geom1_167_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans), -1, 0, 1, 1, 1, 0, "u 'TGeoCombiTrans' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoCombiTrans",1377,G__G__Geom1_167_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans), -1, 0, 1, 1, 1, 0, "u 'TGeoMatrix' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoCombiTrans",1377,G__G__Geom1_167_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans), -1, 0, 2, 1, 1, 0, 
"u 'TGeoTranslation' - 11 - tr u 'TGeoRotation' - 11 - rot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoCombiTrans",1377,G__G__Geom1_167_0_5, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoCombiTrans",1377,G__G__Geom1_167_0_6, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - dx d - 'Double_t' 0 - dy "
"d - 'Double_t' 0 - dz U 'TGeoRotation' - 0 - rot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoCombiTrans",1377,G__G__Geom1_167_0_7, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - dx "
"d - 'Double_t' 0 - dy d - 'Double_t' 0 - dz "
"U 'TGeoRotation' - 0 - rot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Geom1_167_0_8, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans), -1, 1, 1, 1, 1, 0, "u 'TGeoMatrix' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Geom1_167_0_9, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCombiTrans), -1, 1, 1, 1, 1, 0, "u 'TGeoCombiTrans' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Inverse",732,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClone",879,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RegisterYourself",1694,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RotateX",711,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RotateY",712,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RotateZ",713,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - angle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReflectX",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - leftside g - 'Bool_t' 0 'kFALSE' rotonly", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReflectY",798,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - leftside g - 'Bool_t' 0 'kFALSE' rotonly", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReflectZ",799,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - leftside g - 'Bool_t' 0 'kFALSE' rotonly", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDx",488,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDy",489,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dy", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDz",490,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTranslation",1467,G__G__Geom1_167_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGeoTranslation' - 11 - tr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTranslation",1467,G__G__Geom1_167_0_25, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - dx d - 'Double_t' 0 - dy "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTranslation",1467,G__G__Geom1_167_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - vect", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRotation",1148,G__G__Geom1_167_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TGeoRotation' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRotation",1148,G__G__Geom1_167_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoRotation' - 10 - rot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRotation",1136,G__G__Geom1_167_0_29, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoRotation), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTranslation",1455,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRotationMatrix",1765,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetScale",776,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_167_0_33, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoCombiTrans::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_167_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCombiTrans::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_167_0_35, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoCombiTrans::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_167_0_36, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoCombiTrans::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_167_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_167_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCombiTrans::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_167_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCombiTrans::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_167_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCombiTrans::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_167_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCombiTrans::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoCombiTrans", 1503, G__G__Geom1_167_0_45, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoGenTrans(void) {
   /* TGeoGenTrans */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans));
   G__memfunc_setup("TGeoGenTrans",1169,G__G__Geom1_168_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoGenTrans",1169,G__G__Geom1_168_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoGenTrans",1169,G__G__Geom1_168_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans), -1, 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - dx d - 'Double_t' 0 - dy "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - sx "
"d - 'Double_t' 0 - sy d - 'Double_t' 0 - sz "
"U 'TGeoRotation' - 0 - rot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoGenTrans",1169,G__G__Geom1_168_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - dx "
"d - 'Double_t' 0 - dy d - 'Double_t' 0 - dz "
"d - 'Double_t' 0 - sx d - 'Double_t' 0 - sy "
"d - 'Double_t' 0 - sz U 'TGeoRotation' - 0 - rot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Inverse",732,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetScale",788,G__G__Geom1_168_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - sx d - 'Double_t' 0 - sy "
"d - 'Double_t' 0 - sz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetScale",788,G__G__Geom1_168_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeClone",879,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Normalize",945,G__G__Geom1_168_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScale",776,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_168_0_12, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoGenTrans::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_168_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGenTrans::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_168_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoGenTrans::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_168_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoGenTrans::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_168_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__Geom1_168_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGenTrans::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_168_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoGenTrans::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_168_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGenTrans::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_168_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoGenTrans::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoGenTrans", 1169, G__G__Geom1_168_0_24, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans), -1, 0, 1, 1, 1, 0, "u 'TGeoGenTrans' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoGenTrans", 1295, G__G__Geom1_168_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_168_0_26, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoGenTrans), -1, 1, 1, 1, 1, 0, "u 'TGeoGenTrans' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoIdentity(void) {
   /* TGeoIdentity */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIdentity));
   G__memfunc_setup("TGeoIdentity",1209,G__G__Geom1_169_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoIdentity), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoIdentity",1209,G__G__Geom1_169_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoIdentity), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Inverse",732,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LocalToMaster",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LocalToMasterVect",1708,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LocalToMasterBomb",1690,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClone",879,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MasterToLocal",1306,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MasterToLocalVect",1708,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MasterToLocalBomb",1690,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTranslation",1455,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRotationMatrix",1765,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetScale",776,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_169_0_15, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoIdentity::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_169_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoIdentity::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_169_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoIdentity::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_169_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoIdentity::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_169_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__Geom1_169_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoIdentity::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_169_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoIdentity::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_169_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoIdentity::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_169_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoIdentity::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoIdentity", 1209, G__G__Geom1_169_0_27, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoIdentity), -1, 0, 1, 1, 1, 0, "u 'TGeoIdentity' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoIdentity", 1335, G__G__Geom1_169_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_169_0_29, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoIdentity), -1, 1, 1, 1, 1, 0, "u 'TGeoIdentity' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoBBox(void) {
   /* TGeoBBox */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox));
   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("TGeoBBox",730,G__G__Geom1_172_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoBBox",730,G__G__Geom1_172_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - dx d - 'Double_t' 0 - dy "
"d - 'Double_t' 0 - dz D - 'Double_t' 0 '0' origin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoBBox",730,G__G__Geom1_172_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - dx "
"d - 'Double_t' 0 - dy d - 'Double_t' 0 - dz "
"D - 'Double_t' 0 '0' origin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoBBox",730,G__G__Geom1_172_0_5, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AreOverlapping",1439,G__G__Geom1_172_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 4, 3, 1, 0, 
"U 'TGeoBBox' - 10 - box1 U 'TGeoMatrix' - 10 - mat1 "
"U 'TGeoBBox' - 10 - box2 U 'TGeoMatrix' - 10 - mat2", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const TGeoBBox*, const TGeoMatrix*, const TGeoBBox*, const TGeoMatrix*))(&TGeoBBox::AreOverlapping) ), 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,G__G__Geom1_172_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 5, 3, 1, 0, 
"D - 'Double_t' 10 - point d - 'Double_t' 0 - dx "
"d - 'Double_t' 0 - dy d - 'Double_t' 0 - dz "
"D - 'Double_t' 10 - origin", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const Double_t*, Double_t, Double_t, Double_t, const Double_t*))(&TGeoBBox::Contains) ), 0);
   G__memfunc_setup("CouldBeCrossed",1393,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,G__G__Geom1_172_0_15, 100, -1, G__defined_typename("Double_t"), 0, 7, 3, 1, 0, 
"D - 'Double_t' 10 - point D - 'Double_t' 10 - dir "
"d - 'Double_t' 0 - dx d - 'Double_t' 0 - dy "
"d - 'Double_t' 0 - dz D - 'Double_t' 10 - origin "
"d - 'Double_t' 0 'TGeoShape::Big()' stepmax", (char*)NULL, (void*) G__func2void( (Double_t (*)(const Double_t*, const Double_t*, Double_t, Double_t, Double_t, const Double_t*, Double_t))(&TGeoBBox::DistFromInside) ), 0);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,G__G__Geom1_172_0_17, 100, -1, G__defined_typename("Double_t"), 0, 7, 3, 1, 0, 
"D - 'Double_t' 10 - point D - 'Double_t' 10 - dir "
"d - 'Double_t' 0 - dx d - 'Double_t' 0 - dy "
"d - 'Double_t' 0 - dz D - 'Double_t' 10 - origin "
"d - 'Double_t' 0 'TGeoShape::Big()' stepmax", (char*)NULL, (void*) G__func2void( (Double_t (*)(const Double_t*, const Double_t*, Double_t, Double_t, Double_t, const Double_t*, Double_t))(&TGeoBBox::DistFromOutside) ), 0);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisName",1078,(G__InterfaceMethod) NULL,67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - iaxis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisRange",1186,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - iaxis d - 'Double_t' 1 - xlo "
"d - 'Double_t' 1 - xhi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_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("GetByteCount",1213,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFacetArea",1148,G__G__Geom1_172_0_24, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' index", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointsOnFacet",1597,G__G__Geom1_172_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - index i - 'Int_t' 0 - npoints "
"D - 'Double_t' 0 - array", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointsOnSegments",1952,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - npoints D - 'Double_t' 0 - array", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFittingBox",1310,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 8, 
"U 'TGeoBBox' - 10 - parambox U 'TGeoMatrix' - 0 - mat "
"d - 'Double_t' 1 - dx d - 'Double_t' 1 - dy "
"d - 'Double_t' 1 - dz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDX",444,G__G__Geom1_172_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDY",445,G__G__Geom1_172_0_32, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDZ",446,G__G__Geom1_172_0_33, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOrigin",904,G__G__Geom1_172_0_34, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCylType",902,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsValidBox",981,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsNullBox",896,G__G__Geom1_172_0_38, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeBuffer3D",1103,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TBuffer3D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBoxDimensions",1646,G__G__Geom1_172_0_42, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - dx d - 'Double_t' 0 - dy "
"d - 'Double_t' 0 - dz D - 'Double_t' 0 '0' origin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetBoxPoints",1234,G__G__Geom1_172_0_44, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSegsAndPols",1391,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TBuffer3D' - 1 - buffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_172_0_49, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoBBox::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_172_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBBox::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_172_0_51, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoBBox::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_172_0_52, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoBBox::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_172_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_172_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBBox::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_172_0_58, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoBBox::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_172_0_59, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBBox::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_172_0_60, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoBBox::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoBBox", 730, G__G__Geom1_172_0_61, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox), -1, 0, 1, 1, 1, 0, "u 'TGeoBBox' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoBBox", 856, G__G__Geom1_172_0_62, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_172_0_63, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoBBox), -1, 1, 1, 1, 1, 0, "u 'TGeoBBox' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoVolume(void) {
   /* TGeoVolume */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume));
   G__memfunc_setup("TGeoVolume",999,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 1, 1, 2, 0, "u 'TGeoVolume' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 1, 1, 1, 2, 0, "u 'TGeoVolume' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoVolume",999,G__G__Geom1_173_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoVolume",999,G__G__Geom1_173_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name U 'TGeoShape' - 10 - shape "
"U 'TGeoMedium' - 10 '0' med", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("cd",199,G__G__Geom1_173_0_5, 121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - inode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Capacity",814,G__G__Geom1_173_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckShapes",1090,G__G__Geom1_173_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearNodes",992,G__G__Geom1_173_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearShape",984,G__G__Geom1_173_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CleanAll",764,G__G__Geom1_173_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloneVolume",1129,G__G__Geom1_173_0_12, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloneNodesAndConnect",1991,G__G__Geom1_173_0_13, 121, -1, -1, 0, 1, 1, 1, 8, "U 'TGeoVolume' - 0 - newmother", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckGeometry",1322,G__G__Geom1_173_0_14, 121, -1, -1, 0, 4, 1, 1, 8, 
"i - 'Int_t' 0 '1' nrays d - 'Double_t' 0 '0' startx "
"d - 'Double_t' 0 '0' starty d - 'Double_t' 0 '0' startz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckOverlaps",1322,G__G__Geom1_173_0_15, 121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 '0.1' ovlp C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("CountNodes",1026,G__G__Geom1_173_0_16, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '1000' nlevels i - 'Int_t' 0 '0' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Contains",831,G__G__Geom1_173_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsAssembly",1020,G__G__Geom1_173_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsRunTime",896,G__G__Geom1_173_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVolumeMulti",1343,G__G__Geom1_173_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddNode",655,G__G__Geom1_173_0_22, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGeoVolume' - 10 - vol i - 'Int_t' 0 - copy_no "
"U 'TGeoMatrix' - 0 '0' mat C - 'Option_t' 10 '\"\"' option", "most general case", (void*) NULL, 1);
   G__memfunc_setup("AddNodeOffset",1270,G__G__Geom1_173_0_23, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGeoVolume' - 10 - vol i - 'Int_t' 0 - copy_no "
"d - 'Double_t' 0 '0' offset C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddNodeOverlap",1384,G__G__Geom1_173_0_24, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGeoVolume' - 10 - vol i - 'Int_t' 0 - copy_no "
"U 'TGeoMatrix' - 0 '0' mat C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,G__G__Geom1_173_0_25, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 7, 1, 1, 0, 
"C - - 10 - divname i - 'Int_t' 0 - iaxis "
"i - 'Int_t' 0 - ndiv d - 'Double_t' 0 - start "
"d - 'Double_t' 0 - step i - 'Int_t' 0 '0' numed "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("DrawOnly",816,G__G__Geom1_173_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("LegoPlot",806,G__G__Geom1_173_0_29, 85, G__get_linked_tagnum(&G__G__Geom1LN_TH2F), -1, 0, 9, 1, 1, 0, 
"i - 'Int_t' 0 '20' ntheta d - 'Double_t' 0 '0.' themin "
"d - 'Double_t' 0 '180.' themax i - 'Int_t' 0 '60' nphi "
"d - 'Double_t' 0 '0.' phimin d - 'Double_t' 0 '360.' phimax "
"d - 'Double_t' 0 '0.' rmin d - 'Double_t' 0 '9999999' rmax "
"C - 'Option_t' 10 '\"\"' option", "*MENU*", (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("PrintNodes",1030,G__G__Geom1_173_0_31, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintVoxels",1166,G__G__Geom1_173_0_32, 121, -1, -1, 0, 0, 1, 1, 8, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("ReplayCreation",1442,G__G__Geom1_173_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 10 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsActive",792,G__G__Geom1_173_0_35, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsActiveDaughters",1727,G__G__Geom1_173_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsAdded",654,G__G__Geom1_173_0_37, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsReplicated",1209,G__G__Geom1_173_0_38, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSelected",997,G__G__Geom1_173_0_39, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCylVoxels",1125,G__G__Geom1_173_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsXYZVoxels",1096,G__G__Geom1_173_0_41, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsTopVolume",1127,G__G__Geom1_173_0_42, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Geom1_173_0_43, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisible",906,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsVisibleDaughters",1841,G__G__Geom1_173_0_45, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisContainers",1540,G__G__Geom1_173_0_46, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisLeaves",1102,G__G__Geom1_173_0_47, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisOnly",912,G__G__Geom1_173_0_48, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsAllInvisible",1402,G__G__Geom1_173_0_49, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRaytracing",1232,G__G__Geom1_173_0_50, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Import",635,G__G__Geom1_173_0_51, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 3, 3, 1, 0, 
"C - - 10 - filename C - - 10 '\"\"' name "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) G__func2void( (TGeoVolume* (*)(const char*, const char*, Option_t*))(&TGeoVolume::Import) ), 0);
   G__memfunc_setup("Export",642,G__G__Geom1_173_0_52, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - filename C - - 10 '\"\"' name "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNode",775,G__G__Geom1_173_0_53, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindOverlaps",1229,G__G__Geom1_173_0_54, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindMatrixOfDaughterVolume",2647,G__G__Geom1_173_0_55, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentNodeIndex",1921,G__G__Geom1_173_0_56, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNextNodeIndex",1597,G__G__Geom1_173_0_57, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNodes",793,G__G__Geom1_173_0_58, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNdaughters",1333,G__G__Geom1_173_0_59, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNtotal",914,G__G__Geom1_173_0_60, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetByteCount",1213,G__G__Geom1_173_0_61, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGeoManager",1270,G__G__Geom1_173_0_62, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaterial",1103,G__G__Geom1_173_0_63, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMedium",897,G__G__Geom1_173_0_64, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetField",772,G__G__Geom1_173_0_65, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFinder",888,G__G__Geom1_173_0_66, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPatternFinder), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVoxels",929,G__G__Geom1_173_0_67, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIconName",1066,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIndex",792,G__G__Geom1_173_0_69, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TGeoNode' - 10 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNode",678,G__G__Geom1_173_0_70, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNode",678,G__G__Geom1_173_0_71, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNodeIndex",1182,G__G__Geom1_173_0_72, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 8, 
"U 'TGeoNode' - 10 - node I - 'Int_t' 0 - check_list "
"i - 'Int_t' 0 - ncheck", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNumber",905,G__G__Geom1_173_0_73, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOptimalVoxels",1655,G__G__Geom1_173_0_75, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOption",921,(G__InterfaceMethod) NULL,67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointerName",1410,G__G__Geom1_173_0_77, 67, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTransparency",1562,G__G__Geom1_173_0_78, 99, -1, G__defined_typename("Char_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShape",785,G__G__Geom1_173_0_79, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GrabFocus",892,G__G__Geom1_173_0_80, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("Gsord",511,G__G__Geom1_173_0_81, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsStyleDefault",1426,G__G__Geom1_173_0_82, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InspectMaterial",1541,G__G__Geom1_173_0_83, 121, -1, -1, 0, 0, 1, 1, 8, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("InspectShape",1223,G__G__Geom1_173_0_84, 121, -1, -1, 0, 0, 1, 1, 8, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("MakeCopyVolume",1425,G__G__Geom1_173_0_85, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 1, 1, 1, 0, "U 'TGeoShape' - 0 - newshape", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeCopyNodes",1298,G__G__Geom1_173_0_86, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 10 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeReflectedVolume",1924,G__G__Geom1_173_0_87, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 1, 1, 1, 8, "C - - 10 '\"\"' newname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OptimizeVoxels",1490,G__G__Geom1_173_0_88, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("RandomPoints",1246,G__G__Geom1_173_0_89, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '1000000' npoints C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("RandomRays",1024,G__G__Geom1_173_0_90, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 '10000' nrays d - 'Double_t' 0 '0' startx "
"d - 'Double_t' 0 '0' starty d - 'Double_t' 0 '0' startz", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("Raytrace",827,G__G__Geom1_173_0_91, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", "*TOGGLE* *GETTER=IsRaytracing", (void*) NULL, 0);
   G__memfunc_setup("RegisterYourself",1694,G__G__Geom1_173_0_92, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveNode",1012,G__G__Geom1_173_0_93, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReplaceNode",1090,G__G__Geom1_173_0_94, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 4, 1, 1, 0, 
"U 'TGeoNode' - 0 - nodeorig U 'TGeoShape' - 0 '0' newshape "
"U 'TGeoMatrix' - 0 '0' newpos U 'TGeoMedium' - 0 '0' newmed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveAs",579,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"C - - 10 - filename C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SelectVolume",1240,G__G__Geom1_173_0_97, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' clear", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetActivity",1145,G__G__Geom1_173_0_98, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetActiveDaughters",1839,G__G__Geom1_173_0_99, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAsTopVolume",1419,G__G__Geom1_173_0_100, 121, -1, -1, 0, 0, 1, 1, 0, "", "*TOGGLE* *GETTER=IsTopVolume", (void*) NULL, 0);
   G__memfunc_setup("SetAdded",766,G__G__Geom1_173_0_101, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReplicated",1321,G__G__Geom1_173_0_102, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentPoint",1561,G__G__Geom1_173_0_103, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCylVoxels",1237,G__G__Geom1_173_0_104, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNodes",805,G__G__Geom1_173_0_105, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObjArray' - 0 - nodes", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShape",797,G__G__Geom1_173_0_106, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoShape' - 10 - shape", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTransparency",1574,G__G__Geom1_173_0_107, 121, -1, -1, 0, 1, 1, 1, 0, "c - 'Char_t' 0 '0' transparency", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetField",784,G__G__Geom1_173_0_108, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - field", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOption",933,G__G__Geom1_173_0_109, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAttVisibility",1661,G__G__Geom1_173_0_110, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - vis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVisibility",1364,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' vis", "*TOGGLE* *GETTER=IsVisible", (void*) NULL, 1);
   G__memfunc_setup("SetVisContainers",1652,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", "*TOGGLE* *GETTER=IsVisContainers", (void*) NULL, 1);
   G__memfunc_setup("SetVisLeaves",1214,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", "*TOGGLE* *GETTER=IsVisLeaves", (void*) NULL, 1);
   G__memfunc_setup("SetVisOnly",1024,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", "*TOGGLE* *GETTER=IsVisOnly", (void*) NULL, 1);
   G__memfunc_setup("SetLineColor",1203,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - lcolor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineStyle",1221,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - lstyle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineWidth",1204,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 - lwidth", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetInvisible",1233,G__G__Geom1_173_0_118, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMedium",909,G__G__Geom1_173_0_119, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoMedium' - 0 - medium", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVoxelFinder",1426,G__G__Geom1_173_0_120, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVoxelFinder' - 0 - finder", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFinder",900,G__G__Geom1_173_0_121, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoPatternFinder' - 0 - finder", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNumber",917,G__G__Geom1_173_0_122, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - number", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNtotal",926,G__G__Geom1_173_0_123, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ntotal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SortNodes",929,G__G__Geom1_173_0_124, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnmarkSaved",1121,G__G__Geom1_173_0_125, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Valid",496,G__G__Geom1_173_0_126, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("VisibleDaughters",1653,G__G__Geom1_173_0_127, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' vis", "*TOGGLE* *GETTER=IsVisibleDaughters", (void*) NULL, 0);
   G__memfunc_setup("InvisibleAll",1214,G__G__Geom1_173_0_128, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", "*TOGGLE* *GETTER=IsAllInvisible", (void*) NULL, 0);
   G__memfunc_setup("Voxelize",854,G__G__Geom1_173_0_129, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Weight",616,G__G__Geom1_173_0_130, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '0.01' precision C - 'Option_t' 10 '\"va\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("WeightA",681,G__G__Geom1_173_0_131, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_173_0_132, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoVolume::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_173_0_133, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolume::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_173_0_134, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoVolume::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_173_0_135, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoVolume::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_173_0_139, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_173_0_140, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolume::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_173_0_141, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoVolume::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_173_0_142, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolume::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_173_0_143, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoVolume::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoVolume", 1125, G__G__Geom1_173_0_144, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoNode(void) {
   /* TGeoNode */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 1, 1, 1, 2, 0, "u 'TGeoNode' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("cd",199,G__G__Geom1_177_0_6, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckOverlaps",1322,G__G__Geom1_177_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '0.1' ovlp C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("CheckShapes",1090,G__G__Geom1_177_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CountDaughters",1456,G__G__Geom1_177_0_9, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' unique_volumes", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("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("DrawOnly",816,G__G__Geom1_177_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawOverlaps",1242,G__G__Geom1_177_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillIdArray",1075,G__G__Geom1_177_0_15, 121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - ifree i - 'Int_t' 1 - nodeid "
"I - 'Int_t' 0 - array", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNode",775,G__G__Geom1_177_0_16, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TGeoNode' - 10 - node i - 'Int_t' 0 - level", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetByteCount",1213,G__G__Geom1_177_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDaughter",1108,G__G__Geom1_177_0_18, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - ind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Geom1_177_0_19, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetColour",916,G__G__Geom1_177_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIndex",792,G__G__Geom1_177_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFinder",888,G__G__Geom1_177_0_22, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPatternFinder), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMedium",897,G__G__Geom1_177_0_23, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMotherVolume",1543,G__G__Geom1_177_0_24, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNdaughters",1333,G__G__Geom1_177_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNodes",793,G__G__Geom1_177_0_26, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNumber",905,G__G__Geom1_177_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOverlaps",1132,G__G__Geom1_177_0_28, 73, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 1 - novlp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVolume",920,G__G__Geom1_177_0_29, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetObjectInfo",1283,(G__InterfaceMethod) NULL,67, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOptimalVoxels",1655,G__G__Geom1_177_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InspectNode",1116,G__G__Geom1_177_0_32, 121, -1, -1, 0, 0, 1, 1, 8, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsOffset",803,G__G__Geom1_177_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOnScreen",985,G__G__Geom1_177_0_35, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("IsOverlapping",1347,G__G__Geom1_177_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVirtual",931,G__G__Geom1_177_0_37, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisible",906,G__G__Geom1_177_0_38, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisDaughters",1429,G__G__Geom1_177_0_39, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MayOverlap",1024,G__G__Geom1_177_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - iother", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeCopyNode",1183,G__G__Geom1_177_0_41, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,G__G__Geom1_177_0_42, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveAttributes",1462,G__G__Geom1_177_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentPoint",1561,G__G__Geom1_177_0_44, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetVolume",932,G__G__Geom1_177_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - volume", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNumber",917,G__G__Geom1_177_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - number", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOverlapping",1459,G__G__Geom1_177_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVirtual",1043,G__G__Geom1_177_0_48, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVisibility",1364,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' vis", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("SetInvisible",1233,G__G__Geom1_177_0_50, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetAllInvisible",1514,G__G__Geom1_177_0_51, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetMotherVolume",1555,G__G__Geom1_177_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - mother", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOverlaps",1144,G__G__Geom1_177_0_53, 121, -1, -1, 0, 2, 1, 1, 0, 
"I - 'Int_t' 0 - ovlp i - 'Int_t' 0 - novlp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MasterToLocal",1306,G__G__Geom1_177_0_54, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MasterToLocalVect",1708,G__G__Geom1_177_0_55, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LocalToMaster",1306,G__G__Geom1_177_0_56, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LocalToMasterVect",1708,G__G__Geom1_177_0_57, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ls",223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("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("PrintCandidates",1533,G__G__Geom1_177_0_60, 121, -1, -1, 0, 0, 1, 1, 8, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("PrintOverlaps",1369,G__G__Geom1_177_0_61, 121, -1, -1, 0, 0, 1, 1, 8, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("VisibleDaughters",1653,G__G__Geom1_177_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' vis", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_177_0_63, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoNode::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_177_0_64, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNode::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_177_0_65, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoNode::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_177_0_66, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoNode::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_177_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_177_0_71, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNode::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_177_0_72, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoNode::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_177_0_73, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNode::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_177_0_74, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoNode::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoNode", 883, G__G__Geom1_177_0_75, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoVoxelFinder(void) {
   /* TGeoVoxelFinder */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder));
   G__memfunc_setup("TGeoVoxelFinder",1493,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder), -1, 0, 1, 1, 2, 0, "u 'TGeoVoxelFinder' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder), -1, 1, 1, 1, 2, 0, "u 'TGeoVoxelFinder' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildVoxelLimits",1648,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExtraX",892,(G__InterfaceMethod) NULL, 73, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 8, 
"i - 'Int_t' 0 - islice g - 'Bool_t' 0 - left "
"i - 'Int_t' 1 - nextra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExtraY",893,(G__InterfaceMethod) NULL, 73, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 8, 
"i - 'Int_t' 0 - islice g - 'Bool_t' 0 - left "
"i - 'Int_t' 1 - nextra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetExtraZ",894,(G__InterfaceMethod) NULL, 73, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 8, 
"i - 'Int_t' 0 - islice g - 'Bool_t' 0 - left "
"i - 'Int_t' 1 - nextra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIndices",991,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPriority",1154,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 8, "i - 'Int_t' 0 - iaxis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNcandidates",1406,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValidExtra",1300,(G__InterfaceMethod) NULL, 73, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
"I - 'Int_t' 0 - list i - 'Int_t' 1 - ncheck", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValidExtra",1300,(G__InterfaceMethod) NULL, 73, -1, G__defined_typename("Int_t"), 0, 4, 1, 2, 0, 
"i - 'Int_t' 0 - n1 B - 'UChar_t' 0 - array1 "
"I - 'Int_t' 0 - list i - 'Int_t' 1 - ncheck", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValidExtra",1300,(G__InterfaceMethod) NULL, 73, -1, G__defined_typename("Int_t"), 0, 6, 1, 2, 0, 
"i - 'Int_t' 0 - n1 B - 'UChar_t' 0 - array1 "
"i - 'Int_t' 0 - n2 B - 'UChar_t' 0 - array2 "
"I - 'Int_t' 0 - list i - 'Int_t' 1 - ncheck", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVoxelCandidates",1822,(G__InterfaceMethod) NULL, 73, -1, G__defined_typename("Int_t"), 0, 4, 1, 2, 0, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j "
"i - 'Int_t' 0 - k i - 'Int_t' 1 - ncheck", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Intersect",945,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 2, 0, 
"i - 'Int_t' 0 - n1 B - 'UChar_t' 0 - array1 "
"i - 'Int_t' 1 - nf I - 'Int_t' 0 - result", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Intersect",945,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 6, 1, 2, 0, 
"i - 'Int_t' 0 - n1 B - 'UChar_t' 0 - array1 "
"i - 'Int_t' 0 - n2 B - 'UChar_t' 0 - array2 "
"i - 'Int_t' 1 - nf I - 'Int_t' 0 - result", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Intersect",945,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 8, 1, 2, 0, 
"i - 'Int_t' 0 - n1 B - 'UChar_t' 0 - array1 "
"i - 'Int_t' 0 - n2 B - 'UChar_t' 0 - array2 "
"i - 'Int_t' 0 - n3 B - 'UChar_t' 0 - array3 "
"i - 'Int_t' 1 - nf I - 'Int_t' 0 - result", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntersectAndStore",1745,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - n1 B - 'UChar_t' 0 - array1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntersectAndStore",1745,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 2, 0, 
"i - 'Int_t' 0 - n1 B - 'UChar_t' 0 - array1 "
"i - 'Int_t' 0 - n2 B - 'UChar_t' 0 - array2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntersectAndStore",1745,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 6, 1, 2, 0, 
"i - 'Int_t' 0 - n1 B - 'UChar_t' 0 - array1 "
"i - 'Int_t' 0 - n2 B - 'UChar_t' 0 - array2 "
"i - 'Int_t' 0 - n3 B - 'UChar_t' 0 - array3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SortAll",705,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Union",521,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - n1 B - 'UChar_t' 0 - array1", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Union",521,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 2, 0, 
"i - 'Int_t' 0 - n1 B - 'UChar_t' 0 - array1 "
"i - 'Int_t' 0 - n2 B - 'UChar_t' 0 - array2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Union",521,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 6, 1, 2, 0, 
"i - 'Int_t' 0 - n1 B - 'UChar_t' 0 - array1 "
"i - 'Int_t' 0 - n2 B - 'UChar_t' 0 - array2 "
"i - 'Int_t' 0 - n3 B - 'UChar_t' 0 - array3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoVoxelFinder",1493,G__G__Geom1_179_0_24, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoVoxelFinder",1493,G__G__Geom1_179_0_25, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVoxelFinder), -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateCheckList",1486,G__G__Geom1_179_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DaughterToMother",1638,G__G__Geom1_179_0_27, 121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - id D - 'Double_t' 0 - local "
"D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Efficiency",1013,G__G__Geom1_179_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCheckList",1178,G__G__Geom1_179_0_29, 73, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - point i - 'Int_t' 1 - nelem", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCheckList",1178,G__G__Geom1_179_0_30, 73, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 1 - nelem", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNextCandidates",1711,G__G__Geom1_179_0_31, 73, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - point i - 'Int_t' 1 - ncheck", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindOverlaps",1229,G__G__Geom1_179_0_32, 121, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - inode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsInvalid",899,G__G__Geom1_179_0_33, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NeedRebuild",1091,G__G__Geom1_179_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBoxes",801,G__G__Geom1_179_0_35, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSafeVoxel",1097,G__G__Geom1_179_0_36, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 8, 
"D - 'Double_t' 0 - point i - 'Int_t' 0 - inode "
"d - 'Double_t' 0 - minsafe", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintVoxelLimits",1677,G__G__Geom1_179_0_38, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInvalid",1011,G__G__Geom1_179_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNeedRebuild",1391,G__G__Geom1_179_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNextVoxel",1229,G__G__Geom1_179_0_41, 73, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 1 - ncheck", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SortCrossedVoxels",1788,G__G__Geom1_179_0_42, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Voxelize",854,G__G__Geom1_179_0_43, 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__Geom1_179_0_44, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoVoxelFinder::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_179_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVoxelFinder::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_179_0_46, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoVoxelFinder::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_179_0_47, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoVoxelFinder::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_179_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_179_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVoxelFinder::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_179_0_53, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoVoxelFinder::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_179_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVoxelFinder::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_179_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoVoxelFinder::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoVoxelFinder", 1619, G__G__Geom1_179_0_56, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoManager(void) {
   /* TGeoManager */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager));
   G__memfunc_setup("TGeoManager",1066,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager), -1, 0, 1, 1, 2, 0, "u 'TGeoManager' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager), -1, 1, 1, 1, 2, 0, "u 'TGeoManager' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsLoopingVolumes",1663,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitArrayPNE",1142,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InsertPNEId",1029,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0, 
"i - 'Int_t' 0 - uid i - 'Int_t' 0 - ientry", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLoopVolumes",1457,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateElements",1440,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Voxelize",854,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "C - 'Option_t' 10 '0' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoManager",1066,G__G__Geom1_180_0_10, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoManager",1066,G__G__Geom1_180_0_11, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddMaterial",1080,G__G__Geom1_180_0_12, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGeoMaterial' - 10 - material", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddOverlap",994,G__G__Geom1_180_0_13, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TNamed' - 10 - ovlp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTransformation",1760,G__G__Geom1_180_0_14, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGeoMatrix' - 10 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddShape",762,G__G__Geom1_180_0_15, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGeoShape' - 10 - shape", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTrack",766,G__G__Geom1_180_0_16, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - id i - 'Int_t' 0 - pdgcode "
"U 'TObject' - 0 '0' particle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTrack",766,G__G__Geom1_180_0_17, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TVirtualGeoTrack' - 0 - track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddVolume",897,G__G__Geom1_180_0_18, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - volume", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddNavigator",1204,G__G__Geom1_180_0_19, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGeoNavigator' - 0 - navigator", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearOverlaps",1331,G__G__Geom1_180_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterMatrix",1466,G__G__Geom1_180_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoMatrix' - 10 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SortOverlaps",1268,G__G__Geom1_180_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVisibility",1364,G__G__Geom1_180_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 0 - obj g - 'Bool_t' 0 - vis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("cd",199,G__G__Geom1_180_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 '\"\"' path", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("CheckPath",875,G__G__Geom1_180_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "C - - 10 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CdNode",557,G__G__Geom1_180_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nodeid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CdDown",575,G__G__Geom1_180_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CdUp",364,G__G__Geom1_180_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CdTop",474,G__G__Geom1_180_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CdNext",582,G__G__Geom1_180_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBranchNames",1378,G__G__Geom1_180_0_32, 121, -1, -1, 0, 1, 1, 1, 8, "I - 'Int_t' 0 - names", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBranchNumbers",1610,G__G__Geom1_180_0_33, 121, -1, -1, 0, 2, 1, 1, 8, 
"I - 'Int_t' 0 - copyNumbers I - 'Int_t' 0 - volumeNumbers", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBranchOnlys",1411,G__G__Geom1_180_0_34, 121, -1, -1, 0, 1, 1, 1, 8, "I - 'Int_t' 0 - isonly", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNmany",803,G__G__Geom1_180_0_35, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPdgName",956,G__G__Geom1_180_0_36, 67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - pdg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPdgName",968,G__G__Geom1_180_0_37, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - pdg C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Edit",390,G__G__Geom1_180_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("BombTranslation",1551,G__G__Geom1_180_0_40, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - tr D - 'Double_t' 0 - bombtr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UnbombTranslation",1778,G__G__Geom1_180_0_41, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - tr D - 'Double_t' 0 - bombtr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearAttributes",1550,G__G__Geom1_180_0_42, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("DefaultAngles",1311,G__G__Geom1_180_0_43, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("DefaultColors",1335,G__G__Geom1_180_0_44, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("GetClippingShape",1607,G__G__Geom1_180_0_45, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNsegments",1236,G__G__Geom1_180_0_46, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGeomPainter",1403,G__G__Geom1_180_0_47, 85, G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPainter), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPainter",1011,G__G__Geom1_180_0_48, 85, G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPainter), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBombMode",1061,G__G__Geom1_180_0_49, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBombFactors",1394,G__G__Geom1_180_0_50, 121, -1, -1, 0, 4, 1, 1, 8, 
"d - 'Double_t' 1 - bombx d - 'Double_t' 1 - bomby "
"d - 'Double_t' 1 - bombz d - 'Double_t' 1 - bombr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxVisNodes",1393,G__G__Geom1_180_0_51, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTminTmax",1106,G__G__Geom1_180_0_52, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - tmin d - 'Double_t' 1 - tmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTmax",698,G__G__Geom1_180_0_53, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPaintVolume",1428,G__G__Geom1_180_0_54, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVisDensity",1330,G__G__Geom1_180_0_55, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVisLevel",1098,G__G__Geom1_180_0_56, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVisOption",1227,G__G__Geom1_180_0_57, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInPhiRange",1153,G__G__Geom1_180_0_58, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDrawingExtra",1420,G__G__Geom1_180_0_59, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsNodeSelectable",1590,G__G__Geom1_180_0_60, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisLeaves",1102,G__G__Geom1_180_0_61, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ModifiedPad",1078,G__G__Geom1_180_0_62, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OptimizeVoxels",1490,G__G__Geom1_180_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"tgeovox.C\"' filename", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetClipping",1122,G__G__Geom1_180_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetClippingShape",1619,G__G__Geom1_180_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoShape' - 0 - clip", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetExplodedView",1532,G__G__Geom1_180_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' iopt", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetPhiRange",1082,G__G__Geom1_180_0_67, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '0.' phimin d - 'Double_t' 0 '360.' phimax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNsegments",1248,G__G__Geom1_180_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nseg", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetCurrentNavigator",1978,G__G__Geom1_180_0_69, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBombFactors",1406,G__G__Geom1_180_0_70, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 '1.3' bombx d - 'Double_t' 0 '1.3' bomby "
"d - 'Double_t' 0 '1.3' bombz d - 'Double_t' 0 '1.3' bombr", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetPaintVolume",1440,G__G__Geom1_180_0_71, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTopVisible",1325,G__G__Geom1_180_0_72, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' vis", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTminTmax",1118,G__G__Geom1_180_0_73, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '0' tmin d - 'Double_t' 0 '999' tmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawExtraPaths",1726,G__G__Geom1_180_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNodeSelectable",1702,G__G__Geom1_180_0_75, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVisDensity",1342,G__G__Geom1_180_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.01' dens", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetVisLevel",1110,G__G__Geom1_180_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '3' level", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetVisOption",1239,G__G__Geom1_180_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ViewLeaves",1019,G__G__Geom1_180_0_79, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", "*TOGGLE* *GETTER=IsVisLeaves", (void*) NULL, 0);
   G__memfunc_setup("SaveAttributes",1462,G__G__Geom1_180_0_80, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"tgeoatt.C\"' filename", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("RestoreMasterVolume",1992,G__G__Geom1_180_0_81, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetMaxVisNodes",1405,G__G__Geom1_180_0_82, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '10000' maxnodes", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("AnimateTracks",1319,G__G__Geom1_180_0_83, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 '0' tmin d - 'Double_t' 0 '5E-8' tmax "
"i - 'Int_t' 0 '200' nframes C - 'Option_t' 10 '\"/*\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("CheckBoundaryErrors",1951,G__G__Geom1_180_0_84, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '1000000' ntracks d - 'Double_t' 0 '-1.' radius", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("CheckBoundaryReference",2225,G__G__Geom1_180_0_85, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' icheck", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckGeometryFull",1725,G__G__Geom1_180_0_86, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 '1000000' ntracks d - 'Double_t' 0 '0.' vx "
"d - 'Double_t' 0 '0.' vy d - 'Double_t' 0 '0.' vz "
"C - 'Option_t' 10 '\"ob\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("CheckGeometry",1322,G__G__Geom1_180_0_87, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckOverlaps",1322,G__G__Geom1_180_0_88, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '0.1' ovlp C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("CheckPoint",1000,G__G__Geom1_180_0_89, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 '0' x d - 'Double_t' 0 '0' y "
"d - 'Double_t' 0 '0' z C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("ConvertReflections",1887,G__G__Geom1_180_0_90, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawCurrentPoint",1659,G__G__Geom1_180_0_91, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '2' color", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("DrawTracks",1014,G__G__Geom1_180_0_92, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("SetParticleName",1505,G__G__Geom1_180_0_93, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - pname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParticleName",1493,G__G__Geom1_180_0_94, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawPath",795,G__G__Geom1_180_0_95, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintOverlaps",1369,G__G__Geom1_180_0_96, 121, -1, -1, 0, 0, 1, 1, 8, "", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("RandomPoints",1246,G__G__Geom1_180_0_97, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGeoVolume' - 10 - vol i - 'Int_t' 0 '10000' npoints "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RandomRays",1024,G__G__Geom1_180_0_98, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 '1000' nrays d - 'Double_t' 0 '0' startx "
"d - 'Double_t' 0 '0' starty d - 'Double_t' 0 '0' startz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SamplePoints",1247,G__G__Geom1_180_0_99, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - npoints d - 'Double_t' 1 - dist "
"d - 'Double_t' 0 '1E-5' epsil C - - 10 '\"\"' g3path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNmeshPoints",1444,G__G__Geom1_180_0_100, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '1000' npoints", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCheckedNode",1369,G__G__Geom1_180_0_101, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Test",416,G__G__Geom1_180_0_102, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '1000000' npoints C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("TestOverlaps",1260,G__G__Geom1_180_0_103, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' path", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("Weight",616,G__G__Geom1_180_0_104, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 '0.01' precision C - 'Option_t' 10 '\"va\"' option", "*MENU*", (void*) NULL, 0);
   G__memfunc_setup("Division",837,G__G__Geom1_180_0_105, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - mother "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step "
"i - 'Int_t' 0 '0' numed C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Matrix",629,G__G__Geom1_180_0_106, 121, -1, -1, 0, 7, 1, 1, 0, 
"i - 'Int_t' 0 - index d - 'Double_t' 0 - theta1 "
"d - 'Double_t' 0 - phi1 d - 'Double_t' 0 - theta2 "
"d - 'Double_t' 0 - phi2 d - 'Double_t' 0 - theta3 "
"d - 'Double_t' 0 - phi3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Material",815,G__G__Geom1_180_0_107, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - a "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - dens "
"i - 'Int_t' 0 - uid d - 'Double_t' 0 '0' radlen "
"d - 'Double_t' 0 '0' intlen", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mixture",750,G__G__Geom1_180_0_108, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name F - 'Float_t' 0 - a "
"F - 'Float_t' 0 - z d - 'Double_t' 0 - dens "
"i - 'Int_t' 0 - nelem F - 'Float_t' 0 - wmat "
"i - 'Int_t' 0 - uid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mixture",750,G__G__Geom1_180_0_109, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name D - 'Double_t' 0 - a "
"D - 'Double_t' 0 - z d - 'Double_t' 0 - dens "
"i - 'Int_t' 0 - nelem D - 'Double_t' 0 - wmat "
"i - 'Int_t' 0 - uid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Medium",609,G__G__Geom1_180_0_110, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium), -1, 0, 11, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - numed "
"i - 'Int_t' 0 - nmat i - 'Int_t' 0 - isvol "
"i - 'Int_t' 0 - ifield d - 'Double_t' 0 - fieldm "
"d - 'Double_t' 0 - tmaxfd d - 'Double_t' 0 - stemax "
"d - 'Double_t' 0 - deemax d - 'Double_t' 0 - epsil "
"d - 'Double_t' 0 - stmin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Node",390,G__G__Geom1_180_0_111, 121, -1, -1, 0, 10, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - nr "
"C - - 10 - mother d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y d - 'Double_t' 0 - z "
"i - 'Int_t' 0 - irot g - 'Bool_t' 0 - isOnly "
"F - 'Float_t' 0 - upar i - 'Int_t' 0 '0' npar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Node",390,G__G__Geom1_180_0_112, 121, -1, -1, 0, 10, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - nr "
"C - - 10 - mother d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y d - 'Double_t' 0 - z "
"i - 'Int_t' 0 - irot g - 'Bool_t' 0 - isOnly "
"D - 'Double_t' 0 - upar i - 'Int_t' 0 '0' npar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Volume",632,G__G__Geom1_180_0_113, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - shape "
"i - 'Int_t' 0 - nmed F - 'Float_t' 0 - upar "
"i - 'Int_t' 0 '0' npar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Volume",632,G__G__Geom1_180_0_114, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - shape "
"i - 'Int_t' 0 - nmed D - 'Double_t' 0 - upar "
"i - 'Int_t' 0 '0' npar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVolumeAttribute",1880,G__G__Geom1_180_0_115, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - name C - - 10 - att "
"i - 'Int_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildDefaultMaterials",2135,G__G__Geom1_180_0_116, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CloseGeometry",1346,G__G__Geom1_180_0_117, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"d\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsClosed",790,G__G__Geom1_180_0_118, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeArb8",715,G__G__Geom1_180_0_119, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dz D - 'Double_t' 0 '0' vertices", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeBox",679,G__G__Geom1_180_0_120, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dx d - 'Double_t' 0 - dy "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeCone",771,G__G__Geom1_180_0_121, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - rmin1 "
"d - 'Double_t' 0 - rmax1 d - 'Double_t' 0 - rmin2 "
"d - 'Double_t' 0 - rmax2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeCons",785,G__G__Geom1_180_0_122, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 9, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - rmin1 "
"d - 'Double_t' 0 - rmax1 d - 'Double_t' 0 - rmin2 "
"d - 'Double_t' 0 - rmax2 d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - phi2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeCtub",780,G__G__Geom1_180_0_123, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 13, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - phi2 d - 'Double_t' 0 - lx "
"d - 'Double_t' 0 - ly d - 'Double_t' 0 - lz "
"d - 'Double_t' 0 - tx d - 'Double_t' 0 - ty "
"d - 'Double_t' 0 - tz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEltu",792,G__G__Geom1_180_0_124, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - a d - 'Double_t' 0 - b "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeGtra",780,G__G__Geom1_180_0_125, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 14, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - theta "
"d - 'Double_t' 0 - phi d - 'Double_t' 0 - twist "
"d - 'Double_t' 0 - h1 d - 'Double_t' 0 - bl1 "
"d - 'Double_t' 0 - tl1 d - 'Double_t' 0 - alpha1 "
"d - 'Double_t' 0 - h2 d - 'Double_t' 0 - bl2 "
"d - 'Double_t' 0 - tl2 d - 'Double_t' 0 - alpha2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakePara",770,G__G__Geom1_180_0_126, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dx d - 'Double_t' 0 - dy "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - alpha "
"d - 'Double_t' 0 - theta d - 'Double_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakePcon",782,G__G__Geom1_180_0_127, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - phi d - 'Double_t' 0 - dphi "
"i - 'Int_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeParaboloid",1403,G__G__Geom1_180_0_128, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - rlo d - 'Double_t' 0 - rhi "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeHype",788,G__G__Geom1_180_0_129, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - rin d - 'Double_t' 0 - stin "
"d - 'Double_t' 0 - rout d - 'Double_t' 0 - stout "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakePgon",786,G__G__Geom1_180_0_130, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - phi d - 'Double_t' 0 - dphi "
"i - 'Int_t' 0 - nedges i - 'Int_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeSphere",997,G__G__Geom1_180_0_131, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 '0' themin d - 'Double_t' 0 '180' themax "
"d - 'Double_t' 0 '0' phimin d - 'Double_t' 0 '360' phimax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTorus",923,G__G__Geom1_180_0_132, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - r d - 'Double_t' 0 - rmin "
"d - 'Double_t' 0 - rmax d - 'Double_t' 0 '0' phi1 "
"d - 'Double_t' 0 '360' dphi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTrap",789,G__G__Geom1_180_0_133, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 13, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - theta "
"d - 'Double_t' 0 - phi d - 'Double_t' 0 - h1 "
"d - 'Double_t' 0 - bl1 d - 'Double_t' 0 - tl1 "
"d - 'Double_t' 0 - alpha1 d - 'Double_t' 0 - h2 "
"d - 'Double_t' 0 - bl2 d - 'Double_t' 0 - tl2 "
"d - 'Double_t' 0 - alpha2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTrd1",729,G__G__Geom1_180_0_134, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dx1 d - 'Double_t' 0 - dx2 "
"d - 'Double_t' 0 - dy d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTrd2",730,G__G__Geom1_180_0_135, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dx1 d - 'Double_t' 0 - dx2 "
"d - 'Double_t' 0 - dy1 d - 'Double_t' 0 - dy2 "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTube",782,G__G__Geom1_180_0_136, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTubs",796,G__G__Geom1_180_0_137, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - phi2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeXtru",817,G__G__Geom1_180_0_138, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"i - 'Int_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAlignableEntry",1725,G__G__Geom1_180_0_139, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPNEntry), -1, 0, 3, 1, 1, 0, 
"C - - 10 - unique_name C - - 10 - path "
"i - 'Int_t' 0 '-1' uid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAlignableEntry",1713,G__G__Geom1_180_0_140, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPNEntry), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAlignableEntry",1713,G__G__Geom1_180_0_141, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPNEntry), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAlignableEntryByUID",2126,G__G__Geom1_180_0_142, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPNEntry), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - uid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNAlignable",1261,G__G__Geom1_180_0_143, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "g - 'Bool_t' 0 'kFALSE' with_uid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeAlignablePN",1435,G__G__Geom1_180_0_144, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeAlignablePN",1435,G__G__Geom1_180_0_145, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode), -1, 0, 1, 1, 1, 0, "U 'TGeoPNEntry' - 0 - entry", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakePhysicalNode",1601,G__G__Geom1_180_0_146, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode), -1, 0, 1, 1, 1, 0, "C - - 10 '0' path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearPhysicalNodes",1821,G__G__Geom1_180_0_147, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' mustdelete", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RefreshPhysicalNodes",2053,G__G__Geom1_180_0_148, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' lock", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTrack",883,G__G__Geom1_180_0_149, 85, G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - id i - 'Int_t' 0 - pdgcode "
"U 'TObject' - 0 - particle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeVolumeAssembly",1846,G__G__Geom1_180_0_150, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeVolumeMulti",1537,G__G__Geom1_180_0_151, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTopVolume",1239,G__G__Geom1_180_0_152, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CrossBoundaryAndLocate",2233,G__G__Geom1_180_0_153, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - downwards U 'TGeoNode' - 0 - skipnode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNextBoundary",1636,G__G__Geom1_180_0_154, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 'TGeoShape::Big()' stepmax C - - 10 '\"\"' path "
"g - 'Bool_t' 0 'kFALSE' frombdr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNextDaughterBoundary",2456,G__G__Geom1_180_0_155, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 4, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 1 - idaughter g - 'Bool_t' 0 'kFALSE' compmatrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNextBoundaryAndStep",2323,G__G__Geom1_180_0_156, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 'TGeoShape::Big()' stepmax g - 'Bool_t' 0 'kFALSE' compsafe", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNode",775,G__G__Geom1_180_0_157, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' safe_start", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNode",775,G__G__Geom1_180_0_158, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNormal",1002,G__G__Geom1_180_0_159, 68, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' forward", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNormalFast",1400,G__G__Geom1_180_0_160, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitTrack",905,G__G__Geom1_180_0_161, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - point D - 'Double_t' 10 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitTrack",905,G__G__Geom1_180_0_162, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - nx "
"d - 'Double_t' 0 - ny d - 'Double_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetState",1028,G__G__Geom1_180_0_163, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Safety",620,G__G__Geom1_180_0_164, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' inside", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SearchNode",988,G__G__Geom1_180_0_165, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kFALSE' downwards U 'TGeoNode' - 10 '0' skipnode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Step",412,G__G__Geom1_180_0_166, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' is_geom g - 'Bool_t' 0 'kTRUE' cross", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisableInactiveVolumes",2258,G__G__Geom1_180_0_167, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnableInactiveVolumes",2149,G__G__Geom1_180_0_168, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentTrack",1540,G__G__Geom1_180_0_169, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentTrack",1540,G__G__Geom1_180_0_170, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualGeoTrack' - 0 - track", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNtracks",1014,G__G__Geom1_180_0_171, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentTrack",1528,G__G__Geom1_180_0_172, 85, G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastTrack",1193,G__G__Geom1_180_0_173, 85, G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastPoint",1214,G__G__Geom1_180_0_174, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrack",789,G__G__Geom1_180_0_175, 85, G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrackIndex",1293,G__G__Geom1_180_0_176, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrackOfId",1143,G__G__Geom1_180_0_177, 85, G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindTrackWithId",1471,G__G__Geom1_180_0_178, 85, G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParentTrackOfId",1761,G__G__Geom1_180_0_179, 85, G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVirtualLevel",1535,G__G__Geom1_180_0_180, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GotoSafeLevel",1296,G__G__Geom1_180_0_181, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSafeLevel",1175,G__G__Geom1_180_0_182, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSafeDistance",1482,G__G__Geom1_180_0_183, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastSafety",1312,G__G__Geom1_180_0_184, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStep",700,G__G__Geom1_180_0_185, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InspectState",1239,G__G__Geom1_180_0_186, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsAnimatingTracks",1724,G__G__Geom1_180_0_187, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCheckingOverlaps",1828,G__G__Geom1_180_0_188, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsMatrixTransform",1773,G__G__Geom1_180_0_189, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsMatrixReflection",1852,G__G__Geom1_180_0_190, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSameLocation",1403,G__G__Geom1_180_0_191, 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 g - 'Bool_t' 0 'kFALSE' change", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSameLocation",1403,G__G__Geom1_180_0_192, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSamePoint",1100,G__G__Geom1_180_0_193, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 8, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsStartSafe",1097,G__G__Geom1_180_0_194, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCheckingOverlaps",1940,G__G__Geom1_180_0_195, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStartSafe",1209,G__G__Geom1_180_0_196, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMatrixTransform",1885,G__G__Geom1_180_0_197, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMatrixReflection",1964,G__G__Geom1_180_0_198, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStep",712,G__G__Geom1_180_0_199, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCurrentOverlapping",2086,G__G__Geom1_180_0_200, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEntering",1016,G__G__Geom1_180_0_201, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsExiting",916,G__G__Geom1_180_0_202, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsStepEntering",1428,G__G__Geom1_180_0_203, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsStepExiting",1328,G__G__Geom1_180_0_204, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOutside",921,G__G__Geom1_180_0_205, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOnBoundary",1213,G__G__Geom1_180_0_206, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsNullStep",1011,G__G__Geom1_180_0_207, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsActivityEnabled",1716,G__G__Geom1_180_0_208, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOutside",1033,G__G__Geom1_180_0_209, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CleanGarbage",1164,G__G__Geom1_180_0_210, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearShape",984,G__G__Geom1_180_0_211, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoShape' - 10 - shape", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearTracks",1103,G__G__Geom1_180_0_212, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveMaterial",1437,G__G__Geom1_180_0_213, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetUserData",1308,G__G__Geom1_180_0_214, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CountNodes",1026,G__G__Geom1_180_0_215, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TGeoVolume' - 10 '0' vol i - 'Int_t' 0 '10000' nlevels "
"i - 'Int_t' 0 '0' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecuteEvent",1237,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Parse",507,G__G__Geom1_180_0_217, 105, -1, G__defined_typename("Int_t"), 0, 4, 3, 1, 0, 
"C - - 10 - expr u 'TString' - 1 - expr1 "
"u 'TString' - 1 - expr2 u 'TString' - 1 - expr3", (char*)NULL, (void*) G__func2void( (Int_t (*)(const char*, TString&, TString&, TString&))(&TGeoManager::Parse) ), 0);
   G__memfunc_setup("ReplaceVolume",1332,G__G__Geom1_180_0_218, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"U 'TGeoVolume' - 0 - vorig U 'TGeoVolume' - 0 - vnew", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TransformVolumeToAssembly",2615,G__G__Geom1_180_0_219, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - vname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBits",690,G__G__Geom1_180_0_220, 66, -1, G__defined_typename("UChar_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetByteCount",1213,G__G__Geom1_180_0_221, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - 'Option_t' 10 '0' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetIntBuffer",1189,G__G__Geom1_180_0_222, 73, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDblBuffer",1164,G__G__Geom1_180_0_223, 68, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAllIndex",1085,G__G__Geom1_180_0_224, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Export",642,G__G__Geom1_180_0_225, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - filename C - - 10 '\"\"' name "
"C - 'Option_t' 10 '\"v\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("LockGeometry",1237,G__G__Geom1_180_0_226, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoManager::LockGeometry) ), 0);
   G__memfunc_setup("UnlockGeometry",1464,G__G__Geom1_180_0_227, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoManager::UnlockGeometry) ), 0);
   G__memfunc_setup("GetVerboseLevel",1518,G__G__Geom1_180_0_228, 105, -1, G__defined_typename("Int_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Int_t (*)())(&TGeoManager::GetVerboseLevel) ), 0);
   G__memfunc_setup("SetVerboseLevel",1530,G__G__Geom1_180_0_229, 121, -1, -1, 0, 1, 3, 1, 0, "i - 'Int_t' 0 - vl", (char*)NULL, (void*) G__func2void( (void (*)(Int_t))(&TGeoManager::SetVerboseLevel) ), 0);
   G__memfunc_setup("Import",635,G__G__Geom1_180_0_230, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager), -1, 0, 3, 3, 1, 0, 
"C - - 10 - filename C - - 10 '\"\"' name "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) G__func2void( (TGeoManager* (*)(const char*, const char*, Option_t*))(&TGeoManager::Import) ), 0);
   G__memfunc_setup("IsLocked",782,G__G__Geom1_180_0_231, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TGeoManager::IsLocked) ), 0);
   G__memfunc_setup("IsStreamingVoxels",1767,G__G__Geom1_180_0_232, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfNodes",1386,G__G__Geom1_180_0_233, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfPhysicalNodes",2215,G__G__Geom1_180_0_234, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfOverlaps",1725,G__G__Geom1_180_0_235, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfMatrices",1705,G__G__Geom1_180_0_236, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfMaterials",1811,G__G__Geom1_180_0_237, 85, G__get_linked_tagnum(&G__G__Geom1LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfMedia",1361,G__G__Geom1_180_0_238, 85, G__get_linked_tagnum(&G__G__Geom1LN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfVolumes",1628,G__G__Geom1_180_0_239, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfGVolumes",1699,G__G__Geom1_180_0_240, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfShapes",1493,G__G__Geom1_180_0_241, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfGShapes",1564,G__G__Geom1_180_0_242, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfUVolumes",1713,G__G__Geom1_180_0_243, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfTracks",1497,G__G__Geom1_180_0_244, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetListOfNavigators",1935,G__G__Geom1_180_0_245, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObjArray), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetElementTable",1490,G__G__Geom1_180_0_246, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoElementTable), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoBackupState",1290,G__G__Geom1_180_0_247, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRestoreState",1432,G__G__Geom1_180_0_248, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNode",678,G__G__Geom1_180_0_249, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - level", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNodeId",851,G__G__Geom1_180_0_250, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNextNode",1093,G__G__Geom1_180_0_251, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMother",911,G__G__Geom1_180_0_252, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '1' up", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMotherMatrix",1540,G__G__Geom1_180_0_253, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '1' up", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHMatrix",989,G__G__Geom1_180_0_254, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentMatrix",1656,G__G__Geom1_180_0_255, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGLMatrix",1064,G__G__Geom1_180_0_256, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentNavigator",1966,G__G__Geom1_180_0_257, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNavigator), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentNode",1417,G__G__Geom1_180_0_258, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentNodeId",1590,G__G__Geom1_180_0_259, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentPoint",1549,G__G__Geom1_180_0_260, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentDirection",1956,G__G__Geom1_180_0_261, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentVolume",1659,G__G__Geom1_180_0_262, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCldirChecked",1461,G__G__Geom1_180_0_263, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCldir",782,G__G__Geom1_180_0_264, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNormal",905,G__G__Geom1_180_0_265, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLevel",792,G__G__Geom1_180_0_266, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxLevel",1086,G__G__Geom1_180_0_267, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPath",685,G__G__Geom1_180_0_268, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStackLevel",1294,G__G__Geom1_180_0_269, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMasterVolume",1540,G__G__Geom1_180_0_270, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTopVolume",1227,G__G__Geom1_180_0_271, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTopNode",985,G__G__Geom1_180_0_272, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhysicalNode",1507,G__G__Geom1_180_0_273, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentPoint",1561,G__G__Geom1_180_0_274, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentPoint",1561,G__G__Geom1_180_0_275, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLastPoint",1226,G__G__Geom1_180_0_276, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentDirection",1968,G__G__Geom1_180_0_277, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentDirection",1968,G__G__Geom1_180_0_278, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - nx d - 'Double_t' 0 - ny "
"d - 'Double_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCldirChecked",1473,G__G__Geom1_180_0_279, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LocalToMaster",1306,G__G__Geom1_180_0_280, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LocalToMasterVect",1708,G__G__Geom1_180_0_281, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LocalToMasterBomb",1690,G__G__Geom1_180_0_282, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MasterToLocal",1306,G__G__Geom1_180_0_283, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MasterToLocalVect",1708,G__G__Geom1_180_0_284, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MasterToLocalBomb",1690,G__G__Geom1_180_0_285, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MasterToTop",1122,G__G__Geom1_180_0_286, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - top", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TopToMaster",1122,G__G__Geom1_180_0_287, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - top D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindDuplicateMaterial",2123,G__G__Geom1_180_0_288, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 1, 1, 1, 8, "U 'TGeoMaterial' - 10 - mat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindVolumeFast",1415,G__G__Geom1_180_0_289, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name g - 'Bool_t' 0 'kFALSE' multi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaterial",1103,G__G__Geom1_180_0_290, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 1, 1, 1, 8, "C - - 10 - matname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaterial",1103,G__G__Geom1_180_0_291, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMedium",897,G__G__Geom1_180_0_292, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium), -1, 0, 1, 1, 1, 8, "C - - 10 - medium", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMedium",897,G__G__Geom1_180_0_293, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - numed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaterialIndex",1607,G__G__Geom1_180_0_294, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - - 10 - matname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVolume",920,G__G__Geom1_180_0_295, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVolume",920,G__G__Geom1_180_0_296, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - uid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUID",514,G__G__Geom1_180_0_297, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "C - - 10 - volname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNNodes",871,G__G__Geom1_180_0_298, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCache",756,G__G__Geom1_180_0_299, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeCache), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAnimateTracks",1619,G__G__Geom1_180_0_300, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SizeOf",592,G__G__Geom1_180_0_301, 107, -1, G__defined_typename("ULong_t"), 0, 2, 1, 1, 0, 
"U 'TGeoNode' - 10 - node C - 'Option_t' 10 - option", "size of the geometry in memory", (void*) NULL, 1);
   G__memfunc_setup("SelectTrackingMedia",1907,G__G__Geom1_180_0_302, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PushPath",813,G__G__Geom1_180_0_303, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' startlevel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PopPath",700,G__G__Geom1_180_0_304, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PopPath",700,G__G__Geom1_180_0_305, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PushPoint",938,G__G__Geom1_180_0_306, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' startlevel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PopPoint",825,G__G__Geom1_180_0_307, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PopPoint",825,G__G__Geom1_180_0_308, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PopDummy",827,G__G__Geom1_180_0_309, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '9999' ipop", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_180_0_310, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoManager::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_180_0_311, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoManager::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_180_0_312, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoManager::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_180_0_313, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoManager::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_180_0_317, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_180_0_318, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoManager::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_180_0_319, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoManager::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_180_0_320, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoManager::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_180_0_321, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoManager::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoManager", 1192, G__G__Geom1_180_0_322, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoVolumeMulti(void) {
   /* TGeoVolumeMulti */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti));
   G__memfunc_setup("TGeoVolumeMulti",1522,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti), -1, 0, 1, 1, 2, 0, "u 'TGeoVolumeMulti' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti), -1, 1, 1, 1, 2, 0, "u 'TGeoVolumeMulti' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoVolumeMulti",1522,G__G__Geom1_182_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoVolumeMulti",1522,G__G__Geom1_182_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 '0' med", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddVolume",897,G__G__Geom1_182_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVolume",920,G__G__Geom1_182_0_6, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddNode",655,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGeoVolume' - 10 - vol i - 'Int_t' 0 - copy_no "
"U 'TGeoMatrix' - 0 - mat C - 'Option_t' 10 '\"\"' option", "most general case", (void*) NULL, 1);
   G__memfunc_setup("AddNodeOverlap",1384,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGeoVolume' - 10 - vol i - 'Int_t' 0 - copy_no "
"U 'TGeoMatrix' - 0 - mat C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 7, 1, 1, 0, 
"C - - 10 - divname i - 'Int_t' 0 - iaxis "
"i - 'Int_t' 0 - ndiv d - 'Double_t' 0 - start "
"d - 'Double_t' 0 - step i - 'Int_t' 0 '0' numed "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLastShape",1189,G__G__Geom1_182_0_10, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNvolumes",1145,G__G__Geom1_182_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAxis",693,G__G__Geom1_182_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNdiv",689,G__G__Geom1_182_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStart",814,G__G__Geom1_182_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStep",700,G__G__Geom1_182_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVolumeMulti",1343,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeCopyVolume",1425,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 1, 1, 1, 0, "U 'TGeoShape' - 0 - newshape", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineColor",1203,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Color_t' 0 - lcolor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineStyle",1221,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - lstyle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLineWidth",1204,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "s - 'Width_t' 0 - lwidth", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMedium",909,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoMedium' - 0 - medium", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVisibility",1364,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' vis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_182_0_23, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoVolumeMulti::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_182_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeMulti::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_182_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoVolumeMulti::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_182_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoVolumeMulti::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_182_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__Geom1_182_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeMulti::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_182_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoVolumeMulti::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_182_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeMulti::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_182_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoVolumeMulti::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoVolumeMulti", 1648, G__G__Geom1_182_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoVolumeAssembly(void) {
   /* TGeoVolumeAssembly */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly));
   G__memfunc_setup("TGeoVolumeAssembly",1831,G__G__Geom1_183_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoVolumeAssembly",1831,G__G__Geom1_183_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddNode",655,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGeoVolume' - 10 - vol i - 'Int_t' 0 - copy_no "
"U 'TGeoMatrix' - 0 '0' mat C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddNodeOverlap",1384,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGeoVolume' - 10 - vol i - 'Int_t' 0 - copy_no "
"U 'TGeoMatrix' - 0 - mat C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CloneVolume",1129,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 7, 1, 1, 0, 
"C - - 10 - divname i - 'Int_t' 0 - iaxis "
"i - 'Int_t' 0 - ndiv d - 'Double_t' 0 - start "
"d - 'Double_t' 0 - step i - 'Int_t' 0 '0' numed "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DrawOnly",816,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCurrentNodeIndex",1921,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNextNodeIndex",1597,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsAssembly",1020,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsVisible",906,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeAssemblyFromVolume",2250,G__G__Geom1_183_0_12, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly), -1, 0, 1, 3, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) G__func2void( (TGeoVolumeAssembly* (*)(TGeoVolume*))(&TGeoVolumeAssembly::MakeAssemblyFromVolume) ), 0);
   G__memfunc_setup("SetCurrentNodeIndex",1933,G__G__Geom1_183_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNextNodeIndex",1609,G__G__Geom1_183_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_183_0_15, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoVolumeAssembly::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_183_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeAssembly::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_183_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoVolumeAssembly::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_183_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoVolumeAssembly::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_183_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__Geom1_183_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeAssembly::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_183_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoVolumeAssembly::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_183_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeAssembly::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_183_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoVolumeAssembly::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoVolumeAssembly", 1831, G__G__Geom1_183_0_27, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly), -1, 0, 1, 1, 1, 0, "u 'TGeoVolumeAssembly' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoVolumeAssembly", 1957, G__G__Geom1_183_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoNodeMatrix(void) {
   /* TGeoNodeMatrix */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix));
   G__memfunc_setup("TGeoNodeMatrix",1386,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix), -1, 0, 1, 1, 2, 0, "u 'TGeoNodeMatrix' - 11 - gnm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix), -1, 1, 1, 1, 2, 0, "u 'TGeoNodeMatrix' - 11 - gnm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoNodeMatrix",1386,G__G__Geom1_199_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoNodeMatrix",1386,G__G__Geom1_199_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeMatrix), -1, 0, 2, 1, 1, 0, 
"U 'TGeoVolume' - 10 - vol U 'TGeoMatrix' - 10 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetByteCount",1213,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOptimalVoxels",1655,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMatrix",917,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeCopyNode",1183,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMatrix",929,G__G__Geom1_199_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoMatrix' - 10 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_199_0_11, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoNodeMatrix::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_199_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNodeMatrix::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_199_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoNodeMatrix::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_199_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoNodeMatrix::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_199_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__Geom1_199_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNodeMatrix::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_199_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoNodeMatrix::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_199_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNodeMatrix::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_199_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoNodeMatrix::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoNodeMatrix", 1512, G__G__Geom1_199_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoNodeOffset(void) {
   /* TGeoNodeOffset */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset));
   G__memfunc_setup("TGeoNodeOffset",1372,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset), -1, 0, 1, 1, 2, 0, "u 'TGeoNodeOffset' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset), -1, 1, 1, 1, 2, 0, "u 'TGeoNodeOffset' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoNodeOffset",1372,G__G__Geom1_200_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoNodeOffset",1372,G__G__Geom1_200_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeOffset), -1, 0, 3, 1, 1, 0, 
"U 'TGeoVolume' - 10 - vol i - 'Int_t' 0 - index "
"d - 'Double_t' 0 - offset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("cd",199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetOffset",903,G__G__Geom1_200_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIndex",792,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFinder",888,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPatternFinder), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMatrix",917,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeCopyNode",1183,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFinder",900,G__G__Geom1_200_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoPatternFinder' - 10 - finder", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_200_0_12, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoNodeOffset::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_200_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNodeOffset::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_200_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoNodeOffset::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_200_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoNodeOffset::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_200_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__Geom1_200_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNodeOffset::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_200_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoNodeOffset::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_200_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNodeOffset::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_200_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoNodeOffset::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoNodeOffset", 1498, G__G__Geom1_200_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoIterator(void) {
   /* TGeoIterator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIterator));
   G__memfunc_setup("IncreaseArray",1321,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoIterator",1209,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoIterator), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoIterator",1209,G__G__Geom1_201_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoIterator), -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - top", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoIterator",1209,G__G__Geom1_201_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoIterator), -1, 0, 1, 1, 1, 0, "u 'TGeoIterator' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Geom1_201_0_5, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoIterator), -1, 1, 1, 1, 1, 0, "u 'TGeoIterator' - 11 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Geom1_201_0_6, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Next",415,G__G__Geom1_201_0_7, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentMatrix",1656,G__G__Geom1_201_0_8, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMatrix), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIndex",792,G__G__Geom1_201_0_9, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLevel",792,G__G__Geom1_201_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNode",678,G__G__Geom1_201_0_11, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - level", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPath",685,G__G__Geom1_201_0_12, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TString' - 1 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUserPlugin",1326,G__G__Geom1_201_0_13, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoIteratorPlugin), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTopVolume",1227,G__G__Geom1_201_0_14, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__G__Geom1_201_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__Geom1_201_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 '0' top", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUserPlugin",1338,G__G__Geom1_201_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoIteratorPlugin' - 0 - plugin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPluginAutoexec",1753,G__G__Geom1_201_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetType",718,G__G__Geom1_201_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTopName",992,G__G__Geom1_201_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Skip",407,G__G__Geom1_201_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_201_0_22, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoIterator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_201_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoIterator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_201_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoIterator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_201_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoIterator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Geom1_201_0_26, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Geom1_201_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Geom1_201_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_201_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__Geom1_201_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoIterator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_201_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoIterator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_201_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoIterator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_201_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoIterator::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoIterator", 1335, G__G__Geom1_201_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoIteratorPlugin(void) {
   /* TGeoIteratorPlugin */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoIteratorPlugin));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoIteratorPlugin), -1, 1, 1, 1, 4, 0, "u 'TGeoIteratorPlugin' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessNode",1125,G__G__Geom1_202_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetIterator",1142,G__G__Geom1_202_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoIterator' - 10 - iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_202_0_6, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoIteratorPlugin::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_202_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoIteratorPlugin::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_202_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoIteratorPlugin::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_202_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoIteratorPlugin::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_202_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__Geom1_202_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoIteratorPlugin::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_202_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoIteratorPlugin::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_202_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoIteratorPlugin::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_202_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoIteratorPlugin::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoIteratorPlugin", 1958, G__G__Geom1_202_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoPara(void) {
   /* TGeoPara */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara));
   G__memfunc_setup("TGeoPara",755,G__G__Geom1_204_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoPara",755,G__G__Geom1_204_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara), -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - dx d - 'Double_t' 0 - dy "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - alpha "
"d - 'Double_t' 0 - theta d - 'Double_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoPara",755,G__G__Geom1_204_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - dx "
"d - 'Double_t' 0 - dy d - 'Double_t' 0 - dz "
"d - 'Double_t' 0 - alpha d - 'Double_t' 0 - theta "
"d - 'Double_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoPara",755,G__G__Geom1_204_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisRange",1186,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - iaxis d - 'Double_t' 1 - xlo "
"d - 'Double_t' 1 - xhi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetByteCount",1213,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFittingBox",1310,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 8, 
"U 'TGeoBBox' - 10 - parambox U 'TGeoMatrix' - 0 - mat "
"d - 'Double_t' 1 - dx d - 'Double_t' 1 - dy "
"d - 'Double_t' 1 - dz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetX",376,G__G__Geom1_204_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY",377,G__G__Geom1_204_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZ",378,G__G__Geom1_204_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAlpha",774,G__G__Geom1_204_0_21, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTheta",790,G__G__Geom1_204_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhi",577,G__G__Geom1_204_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTxy",613,G__G__Geom1_204_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTxz",614,G__G__Geom1_204_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTyz",615,G__G__Geom1_204_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCylType",902,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_204_0_35, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPara::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_204_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPara::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_204_0_37, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPara::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_204_0_38, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPara::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_204_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_204_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPara::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_204_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPara::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_204_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPara::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_204_0_46, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPara::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoPara", 755, G__G__Geom1_204_0_47, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara), -1, 0, 1, 1, 1, 0, "u 'TGeoPara' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoPara", 881, G__G__Geom1_204_0_48, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_204_0_49, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoPara), -1, 1, 1, 1, 1, 0, "u 'TGeoPara' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoTube(void) {
   /* TGeoTube */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube));
   G__memfunc_setup("TGeoTube",767,G__G__Geom1_205_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTube",767,G__G__Geom1_205_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTube",767,G__G__Geom1_205_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - rmin "
"d - 'Double_t' 0 - rmax d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTube",767,G__G__Geom1_205_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Capacity",814,G__G__Geom1_205_0_6, 100, -1, G__defined_typename("Double_t"), 0, 3, 3, 1, 0, 
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t, Double_t, Double_t))(&TGeoTube::Capacity) ), 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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ComputeNormalS",1433,G__G__Geom1_205_0_9, 121, -1, -1, 0, 6, 3, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm d - 'Double_t' 0 - rmin "
"d - 'Double_t' 0 - rmax d - 'Double_t' 0 - dz", (char*)NULL, (void*) G__func2void( (void (*)(Double_t*, Double_t*, Double_t*, Double_t, Double_t, Double_t))(&TGeoTube::ComputeNormalS) ), 0);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInsideS",1495,G__G__Geom1_205_0_11, 100, -1, G__defined_typename("Double_t"), 0, 5, 3, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t*, Double_t*, Double_t, Double_t, Double_t))(&TGeoTube::DistFromInsideS) ), 0);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutsideS",1624,G__G__Geom1_205_0_13, 100, -1, G__defined_typename("Double_t"), 0, 5, 3, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t*, Double_t*, Double_t, Double_t, Double_t))(&TGeoTube::DistFromOutsideS) ), 0);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistToTube",999,G__G__Geom1_205_0_15, 121, -1, -1, 0, 6, 3, 1, 0, 
"d - 'Double_t' 0 - rsq d - 'Double_t' 0 - nsq "
"d - 'Double_t' 0 - rdotn d - 'Double_t' 0 - radius "
"d - 'Double_t' 1 - b d - 'Double_t' 1 - delta", (char*)NULL, (void*) G__func2void( (void (*)(Double_t, Double_t, Double_t, Double_t, Double_t&, Double_t&))(&TGeoTube::DistToTube) ), 0);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisName",1078,(G__InterfaceMethod) NULL,67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - iaxis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisRange",1186,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - iaxis d - 'Double_t' 1 - xlo "
"d - 'Double_t' 1 - xhi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_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("GetByteCount",1213,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointsOnSegments",1952,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - npoints D - 'Double_t' 0 - array", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRmin",694,G__G__Geom1_205_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRmax",696,G__G__Geom1_205_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDz",478,G__G__Geom1_205_0_29, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasRmin",690,G__G__Geom1_205_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCylType",902,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeBuffer3D",1103,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TBuffer3D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SafetyS",703,G__G__Geom1_205_0_35, 100, -1, G__defined_typename("Double_t"), 0, 6, 3, 1, 0, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 - in "
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz i - 'Int_t' 0 '0' skipz", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t*, Bool_t, Double_t, Double_t, Double_t, Int_t))(&TGeoTube::SafetyS) ), 0);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTubeDimensions",1749,G__G__Geom1_205_0_37, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSegsAndPols",1391,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TBuffer3D' - 1 - buff", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_205_0_43, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTube::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_205_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTube::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_205_0_45, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTube::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_205_0_46, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTube::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_205_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_205_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTube::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_205_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTube::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_205_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTube::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_205_0_54, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTube::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoTube", 767, G__G__Geom1_205_0_55, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube), -1, 0, 1, 1, 1, 0, "u 'TGeoTube' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoTube", 893, G__G__Geom1_205_0_56, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_205_0_57, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoTube), -1, 1, 1, 1, 1, 0, "u 'TGeoTube' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoTubeSeg(void) {
   /* TGeoTubeSeg */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg));
   G__memfunc_setup("TGeoTubeSeg",1054,G__G__Geom1_206_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTubeSeg",1054,G__G__Geom1_206_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg), -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - phi2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTubeSeg",1054,G__G__Geom1_206_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - rmin "
"d - 'Double_t' 0 - rmax d - 'Double_t' 0 - dz "
"d - 'Double_t' 0 - phi1 d - 'Double_t' 0 - phi2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTubeSeg",1054,G__G__Geom1_206_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Capacity",814,G__G__Geom1_206_0_6, 100, -1, G__defined_typename("Double_t"), 0, 5, 3, 1, 0, 
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - phi2", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t, Double_t, Double_t, Double_t, Double_t))(&TGeoTubeSeg::Capacity) ), 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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ComputeNormalS",1433,G__G__Geom1_206_0_9, 121, -1, -1, 0, 10, 3, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm d - 'Double_t' 0 - rmin "
"d - 'Double_t' 0 - rmax d - 'Double_t' 0 - dz "
"d - 'Double_t' 0 - c1 d - 'Double_t' 0 - s1 "
"d - 'Double_t' 0 - c2 d - 'Double_t' 0 - s2", (char*)NULL, (void*) G__func2void( (void (*)(Double_t*, Double_t*, Double_t*, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t))(&TGeoTubeSeg::ComputeNormalS) ), 0);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInsideS",1495,G__G__Geom1_206_0_12, 100, -1, G__defined_typename("Double_t"), 0, 12, 3, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - c1 "
"d - 'Double_t' 0 - s1 d - 'Double_t' 0 - c2 "
"d - 'Double_t' 0 - s2 d - 'Double_t' 0 - cm "
"d - 'Double_t' 0 - sm d - 'Double_t' 0 - cdfi", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t*, Double_t*, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t))(&TGeoTubeSeg::DistFromInsideS) ), 0);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutsideS",1624,G__G__Geom1_206_0_14, 100, -1, G__defined_typename("Double_t"), 0, 12, 3, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - c1 "
"d - 'Double_t' 0 - s1 d - 'Double_t' 0 - c2 "
"d - 'Double_t' 0 - s2 d - 'Double_t' 0 - cm "
"d - 'Double_t' 0 - sm d - 'Double_t' 0 - cdfi", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t*, Double_t*, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t))(&TGeoTubeSeg::DistFromOutsideS) ), 0);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisRange",1186,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - iaxis d - 'Double_t' 1 - xlo "
"d - 'Double_t' 1 - xhi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_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("GetByteCount",1213,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointsOnSegments",1952,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - npoints D - 'Double_t' 0 - array", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPhi1",626,G__G__Geom1_206_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhi2",627,G__G__Geom1_206_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeBuffer3D",1103,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TBuffer3D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SafetyS",703,G__G__Geom1_206_0_30, 100, -1, G__defined_typename("Double_t"), 0, 8, 3, 1, 0, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 - in "
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - phi2 i - 'Int_t' 0 '0' skipz", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t*, Bool_t, Double_t, Double_t, Double_t, Double_t, Double_t, Int_t))(&TGeoTubeSeg::SafetyS) ), 0);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTubsDimensions",1763,G__G__Geom1_206_0_32, 121, -1, -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - phi2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSegsAndPols",1391,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TBuffer3D' - 1 - buff", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_206_0_38, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTubeSeg::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_206_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTubeSeg::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_206_0_40, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTubeSeg::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_206_0_41, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTubeSeg::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_206_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_206_0_46, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTubeSeg::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_206_0_47, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTubeSeg::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_206_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTubeSeg::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_206_0_49, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTubeSeg::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoTubeSeg", 1054, G__G__Geom1_206_0_50, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg), -1, 0, 1, 1, 1, 0, "u 'TGeoTubeSeg' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoTubeSeg", 1180, G__G__Geom1_206_0_51, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_206_0_52, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoTubeSeg), -1, 1, 1, 1, 1, 0, "u 'TGeoTubeSeg' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoCtub(void) {
   /* TGeoCtub */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub));
   G__memfunc_setup("TGeoCtub",765,G__G__Geom1_207_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoCtub",765,G__G__Geom1_207_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub), -1, 0, 11, 1, 1, 0, 
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - phi2 d - 'Double_t' 0 - lx "
"d - 'Double_t' 0 - ly d - 'Double_t' 0 - lz "
"d - 'Double_t' 0 - tx d - 'Double_t' 0 - ty "
"d - 'Double_t' 0 - tz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoCtub",765,G__G__Geom1_207_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub), -1, 0, 12, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - rmin "
"d - 'Double_t' 0 - rmax d - 'Double_t' 0 - dz "
"d - 'Double_t' 0 - phi1 d - 'Double_t' 0 - phi2 "
"d - 'Double_t' 0 - lx d - 'Double_t' 0 - ly "
"d - 'Double_t' 0 - lz d - 'Double_t' 0 - tx "
"d - 'Double_t' 0 - ty d - 'Double_t' 0 - tz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoCtub",765,G__G__Geom1_207_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisRange",1186,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - iaxis d - 'Double_t' 1 - xlo "
"d - 'Double_t' 1 - xhi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_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("GetByteCount",1213,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointsOnSegments",1952,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - npoints D - 'Double_t' 0 - array", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNlow",704,G__G__Geom1_207_0_19, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNhigh",782,G__G__Geom1_207_0_20, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZcoord",913,G__G__Geom1_207_0_21, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"d - 'Double_t' 0 - xc d - 'Double_t' 0 - yc "
"d - 'Double_t' 0 - zc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCtubDimensions",1747,G__G__Geom1_207_0_25, 121, -1, -1, 0, 11, 1, 1, 0, 
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - phi2 d - 'Double_t' 0 - lx "
"d - 'Double_t' 0 - ly d - 'Double_t' 0 - lz "
"d - 'Double_t' 0 - tx d - 'Double_t' 0 - ty "
"d - 'Double_t' 0 - tz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_207_0_29, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoCtub::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_207_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCtub::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_207_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoCtub::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_207_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoCtub::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_207_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__Geom1_207_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCtub::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_207_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCtub::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_207_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCtub::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_207_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCtub::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoCtub", 765, G__G__Geom1_207_0_41, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub), -1, 0, 1, 1, 1, 0, "u 'TGeoCtub' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoCtub", 891, G__G__Geom1_207_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_207_0_43, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoCtub), -1, 1, 1, 1, 1, 0, "u 'TGeoCtub' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoTorus(void) {
   /* TGeoTorus */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus));
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Daxis",505,G__G__Geom1_208_0_2, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"D - 'Double_t' 0 - pt D - 'Double_t' 0 - dir "
"d - 'Double_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DDaxis",573,G__G__Geom1_208_0_3, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"D - 'Double_t' 0 - pt D - 'Double_t' 0 - dir "
"d - 'Double_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DDDaxis",641,G__G__Geom1_208_0_4, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"D - 'Double_t' 0 - pt D - 'Double_t' 0 - dir "
"d - 'Double_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ToBoundary",1031,G__G__Geom1_208_0_5, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"D - 'Double_t' 0 - pt D - 'Double_t' 0 - dir "
"d - 'Double_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SolveCubic",1007,G__G__Geom1_208_0_6, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 8, 
"d - 'Double_t' 0 - a d - 'Double_t' 0 - b "
"d - 'Double_t' 0 - c D - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SolveQuartic",1250,G__G__Geom1_208_0_7, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 8, 
"d - 'Double_t' 0 - a d - 'Double_t' 0 - b "
"d - 'Double_t' 0 - c d - 'Double_t' 0 - d "
"D - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTorus",908,G__G__Geom1_208_0_8, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTorus",908,G__G__Geom1_208_0_9, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus), -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - r d - 'Double_t' 0 - rmin "
"d - 'Double_t' 0 - rmax d - 'Double_t' 0 '0' phi1 "
"d - 'Double_t' 0 '360' dphi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTorus",908,G__G__Geom1_208_0_10, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - r "
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 '0' phi1 d - 'Double_t' 0 '360' dphi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTorus",908,G__G__Geom1_208_0_11, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - params", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisName",1078,(G__InterfaceMethod) NULL,67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - iaxis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisRange",1186,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - iaxis d - 'Double_t' 1 - xlo "
"d - 'Double_t' 1 - xhi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_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("GetByteCount",1213,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointsOnSegments",1952,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - - D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetR",370,G__G__Geom1_208_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRmin",694,G__G__Geom1_208_0_29, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRmax",696,G__G__Geom1_208_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhi1",626,G__G__Geom1_208_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDphi",677,G__G__Geom1_208_0_32, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCylType",902,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeBuffer3D",1103,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TBuffer3D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTorusDimensions",1890,G__G__Geom1_208_0_38, 121, -1, -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - r d - 'Double_t' 0 - rmin "
"d - 'Double_t' 0 - rmax d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - dphi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSegsAndPols",1391,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TBuffer3D' - 1 - buff", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_208_0_44, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTorus::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_208_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTorus::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_208_0_46, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTorus::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_208_0_47, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTorus::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_208_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_208_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTorus::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_208_0_53, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTorus::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_208_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTorus::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_208_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTorus::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoTorus", 908, G__G__Geom1_208_0_56, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus), -1, 0, 1, 1, 1, 0, "u 'TGeoTorus' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoTorus", 1034, G__G__Geom1_208_0_57, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_208_0_58, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoTorus), -1, 1, 1, 1, 1, 0, "u 'TGeoTorus' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoSphere(void) {
   /* TGeoSphere */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere));
   G__memfunc_setup("TGeoSphere",982,G__G__Geom1_209_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoSphere",982,G__G__Geom1_209_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere), -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 '0' theta1 d - 'Double_t' 0 '180' theta2 "
"d - 'Double_t' 0 '0' phi1 d - 'Double_t' 0 '360' phi2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoSphere",982,G__G__Geom1_209_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - rmin "
"d - 'Double_t' 0 - rmax d - 'Double_t' 0 '0' theta1 "
"d - 'Double_t' 0 '180' theta2 d - 'Double_t' 0 '0' phi1 "
"d - 'Double_t' 0 '360' phi2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoSphere",982,G__G__Geom1_209_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere), -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - param i - 'Int_t' 0 '6' nparam", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistToSphere",1214,G__G__Geom1_209_0_12, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"d - 'Double_t' 0 - rsph g - 'Bool_t' 0 'kTRUE' check "
"g - 'Bool_t' 0 'kTRUE' firstcross", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisName",1078,(G__InterfaceMethod) NULL,67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - iaxis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisRange",1186,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - iaxis d - 'Double_t' 1 - xlo "
"d - 'Double_t' 1 - xhi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_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("GetByteCount",1213,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - - U 'TGeoMatrix' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumberOfDivisions",2038,G__G__Geom1_209_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPointsOnSegments",1952,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - - D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNz",488,G__G__Geom1_209_0_24, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRmin",694,G__G__Geom1_209_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRmax",696,G__G__Geom1_209_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTheta1",839,G__G__Geom1_209_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTheta2",840,G__G__Geom1_209_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhi1",626,G__G__Geom1_209_0_29, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhi2",627,G__G__Geom1_209_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCylType",902,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsOnBoundary",1213,G__G__Geom1_209_0_33, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsPointInside",1314,G__G__Geom1_209_0_34, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' checkR "
"g - 'Bool_t' 0 'kTRUE' checkTh g - 'Bool_t' 0 'kTRUE' checkPh", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeBuffer3D",1103,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TBuffer3D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSphDimensions",1648,G__G__Geom1_209_0_38, 121, -1, -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - theta1 d - 'Double_t' 0 - theta2 "
"d - 'Double_t' 0 - phi1 d - 'Double_t' 0 - phi2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNumberOfDivisions",2050,G__G__Geom1_209_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSegsAndPols",1391,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TBuffer3D' - 1 - buff", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_209_0_45, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoSphere::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_209_0_46, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoSphere::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_209_0_47, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoSphere::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_209_0_48, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoSphere::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_209_0_52, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_209_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoSphere::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_209_0_54, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoSphere::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_209_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoSphere::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_209_0_56, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoSphere::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoSphere", 982, G__G__Geom1_209_0_57, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere), -1, 0, 1, 1, 1, 0, "u 'TGeoSphere' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoSphere", 1108, G__G__Geom1_209_0_58, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_209_0_59, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoSphere), -1, 1, 1, 1, 1, 0, "u 'TGeoSphere' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoEltu(void) {
   /* TGeoEltu */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu));
   G__memfunc_setup("TGeoEltu",777,G__G__Geom1_210_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoEltu",777,G__G__Geom1_210_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - a d - 'Double_t' 0 - b "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoEltu",777,G__G__Geom1_210_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - a "
"d - 'Double_t' 0 - b d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoEltu",777,G__G__Geom1_210_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetA",353,G__G__Geom1_210_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetB",354,G__G__Geom1_210_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_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("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointsOnSegments",1952,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - - D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCylType",902,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetEltuDimensions",1759,G__G__Geom1_210_0_25, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - a d - 'Double_t' 0 - b "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_210_0_29, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoEltu::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_210_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoEltu::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_210_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoEltu::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_210_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoEltu::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_210_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__Geom1_210_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoEltu::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_210_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoEltu::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_210_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoEltu::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_210_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoEltu::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoEltu", 777, G__G__Geom1_210_0_41, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu), -1, 0, 1, 1, 1, 0, "u 'TGeoEltu' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoEltu", 903, G__G__Geom1_210_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_210_0_43, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoEltu), -1, 1, 1, 1, 1, 0, "u 'TGeoEltu' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoHype(void) {
   /* TGeoHype */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype));
   G__memfunc_setup("TGeoHype",773,G__G__Geom1_211_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoHype",773,G__G__Geom1_211_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype), -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - rin d - 'Double_t' 0 - stin "
"d - 'Double_t' 0 - rout d - 'Double_t' 0 - stout "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoHype",773,G__G__Geom1_211_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - rin "
"d - 'Double_t' 0 - stin d - 'Double_t' 0 - rout "
"d - 'Double_t' 0 - stout d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoHype",773,G__G__Geom1_211_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistToHype",1005,G__G__Geom1_211_0_11, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - s g - 'Bool_t' 0 - inner", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisRange",1186,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - iaxis d - 'Double_t' 1 - xlo "
"d - 'Double_t' 1 - xhi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_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("GetByteCount",1213,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointsOnSegments",1952,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - - D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStIn",670,G__G__Geom1_211_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStOut",799,G__G__Geom1_211_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasInner",792,G__G__Geom1_211_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RadiusHypeSq",1218,G__G__Geom1_211_0_25, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 - z g - 'Bool_t' 0 - inner", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ZHypeSq",692,G__G__Geom1_211_0_26, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 - r g - 'Bool_t' 0 - inner", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCylType",902,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeBuffer3D",1103,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TBuffer3D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SafetyToHype",1221,G__G__Geom1_211_0_31, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 - inner "
"g - 'Bool_t' 0 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHypeDimensions",1755,G__G__Geom1_211_0_33, 121, -1, -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - rin d - 'Double_t' 0 - stin "
"d - 'Double_t' 0 - rout d - 'Double_t' 0 - stout "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSegsAndPols",1391,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TBuffer3D' - 1 - buff", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_211_0_39, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoHype::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_211_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHype::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_211_0_41, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoHype::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_211_0_42, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoHype::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_211_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__Geom1_211_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHype::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_211_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoHype::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_211_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHype::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_211_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoHype::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoHype", 773, G__G__Geom1_211_0_51, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype), -1, 0, 1, 1, 1, 0, "u 'TGeoHype' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoHype", 899, G__G__Geom1_211_0_52, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_211_0_53, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoHype), -1, 1, 1, 1, 1, 0, "u 'TGeoHype' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoCone(void) {
   /* TGeoCone */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone));
   G__memfunc_setup("TGeoCone",756,G__G__Geom1_212_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoCone",756,G__G__Geom1_212_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone), -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - rmin1 "
"d - 'Double_t' 0 - rmax1 d - 'Double_t' 0 - rmin2 "
"d - 'Double_t' 0 - rmax2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoCone",756,G__G__Geom1_212_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - dz "
"d - 'Double_t' 0 - rmin1 d - 'Double_t' 0 - rmax1 "
"d - 'Double_t' 0 - rmin2 d - 'Double_t' 0 - rmax2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoCone",756,G__G__Geom1_212_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Capacity",814,G__G__Geom1_212_0_6, 100, -1, G__defined_typename("Double_t"), 0, 5, 3, 1, 0, 
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - rmin1 "
"d - 'Double_t' 0 - rmax1 d - 'Double_t' 0 - rmin2 "
"d - 'Double_t' 0 - rmax2", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t, Double_t, Double_t, Double_t, Double_t))(&TGeoCone::Capacity) ), 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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ComputeNormalS",1433,G__G__Geom1_212_0_9, 121, -1, -1, 0, 8, 3, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm d - 'Double_t' 0 - dz "
"d - 'Double_t' 0 - rmin1 d - 'Double_t' 0 - rmax1 "
"d - 'Double_t' 0 - rmin2 d - 'Double_t' 0 - rmax2", (char*)NULL, (void*) G__func2void( (void (*)(Double_t*, Double_t*, Double_t*, Double_t, Double_t, Double_t, Double_t, Double_t))(&TGeoCone::ComputeNormalS) ), 0);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistToCone",988,G__G__Geom1_212_0_12, 121, -1, -1, 0, 7, 3, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - r1 "
"d - 'Double_t' 0 - r2 d - 'Double_t' 1 - b "
"d - 'Double_t' 1 - delta", (char*)NULL, (void*) G__func2void( (void (*)(Double_t*, Double_t*, Double_t, Double_t, Double_t, Double_t&, Double_t&))(&TGeoCone::DistToCone) ), 0);
   G__memfunc_setup("DistFromInsideS",1495,G__G__Geom1_212_0_13, 100, -1, G__defined_typename("Double_t"), 0, 7, 3, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - rmin1 "
"d - 'Double_t' 0 - rmax1 d - 'Double_t' 0 - rmin2 "
"d - 'Double_t' 0 - rmax2", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t*, Double_t*, Double_t, Double_t, Double_t, Double_t, Double_t))(&TGeoCone::DistFromInsideS) ), 0);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutsideS",1624,G__G__Geom1_212_0_15, 100, -1, G__defined_typename("Double_t"), 0, 7, 3, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - rmin1 "
"d - 'Double_t' 0 - rmax1 d - 'Double_t' 0 - rmin2 "
"d - 'Double_t' 0 - rmax2", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t*, Double_t*, Double_t, Double_t, Double_t, Double_t, Double_t))(&TGeoCone::DistFromOutsideS) ), 0);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisName",1078,(G__InterfaceMethod) NULL,67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - iaxis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisRange",1186,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - iaxis d - 'Double_t' 1 - xlo "
"d - 'Double_t' 1 - xhi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetByteCount",1213,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_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("GetDz",478,G__G__Geom1_212_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointsOnSegments",1952,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - npoints D - 'Double_t' 0 - array", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRmin1",743,G__G__Geom1_212_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRmax1",745,G__G__Geom1_212_0_29, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRmin2",744,G__G__Geom1_212_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRmax2",746,G__G__Geom1_212_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCylType",902,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeBuffer3D",1103,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TBuffer3D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SafetyS",703,G__G__Geom1_212_0_36, 100, -1, G__defined_typename("Double_t"), 0, 8, 3, 1, 0, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 - in "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - rmin1 "
"d - 'Double_t' 0 - rmax1 d - 'Double_t' 0 - rmin2 "
"d - 'Double_t' 0 - rmax2 i - 'Int_t' 0 '0' skipz", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t*, Bool_t, Double_t, Double_t, Double_t, Double_t, Double_t, Int_t))(&TGeoCone::SafetyS) ), 0);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConeDimensions",1738,G__G__Geom1_212_0_38, 121, -1, -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - rmin1 "
"d - 'Double_t' 0 - rmax1 d - 'Double_t' 0 - rmin2 "
"d - 'Double_t' 0 - rmax2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSegsAndPols",1391,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TBuffer3D' - 1 - buffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_212_0_44, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoCone::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_212_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCone::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_212_0_46, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoCone::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_212_0_47, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoCone::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_212_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_212_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCone::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_212_0_53, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCone::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_212_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCone::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_212_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCone::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoCone", 756, G__G__Geom1_212_0_56, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone), -1, 0, 1, 1, 1, 0, "u 'TGeoCone' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoCone", 882, G__G__Geom1_212_0_57, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_212_0_58, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoCone), -1, 1, 1, 1, 1, 0, "u 'TGeoCone' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoConeSeg(void) {
   /* TGeoConeSeg */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg));
   G__memfunc_setup("TGeoConeSeg",1043,G__G__Geom1_213_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoConeSeg",1043,G__G__Geom1_213_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg), -1, 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - rmin1 "
"d - 'Double_t' 0 - rmax1 d - 'Double_t' 0 - rmin2 "
"d - 'Double_t' 0 - rmax2 d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - phi2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoConeSeg",1043,G__G__Geom1_213_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - dz "
"d - 'Double_t' 0 - rmin1 d - 'Double_t' 0 - rmax1 "
"d - 'Double_t' 0 - rmin2 d - 'Double_t' 0 - rmax2 "
"d - 'Double_t' 0 - phi1 d - 'Double_t' 0 - phi2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoConeSeg",1043,G__G__Geom1_213_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Capacity",814,G__G__Geom1_213_0_6, 100, -1, G__defined_typename("Double_t"), 0, 7, 3, 1, 0, 
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - rmin1 "
"d - 'Double_t' 0 - rmax1 d - 'Double_t' 0 - rmin2 "
"d - 'Double_t' 0 - rmax2 d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - phi2", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t))(&TGeoConeSeg::Capacity) ), 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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ComputeNormalS",1433,G__G__Geom1_213_0_9, 121, -1, -1, 0, 12, 3, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm d - 'Double_t' 0 - dz "
"d - 'Double_t' 0 - rmin1 d - 'Double_t' 0 - rmax1 "
"d - 'Double_t' 0 - rmin2 d - 'Double_t' 0 - rmax2 "
"d - 'Double_t' 0 - c1 d - 'Double_t' 0 - s1 "
"d - 'Double_t' 0 - c2 d - 'Double_t' 0 - s2", (char*)NULL, (void*) G__func2void( (void (*)(Double_t*, Double_t*, Double_t*, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t))(&TGeoConeSeg::ComputeNormalS) ), 0);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistToCons",1002,G__G__Geom1_213_0_12, 100, -1, G__defined_typename("Double_t"), 0, 8, 3, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"d - 'Double_t' 0 - r1 d - 'Double_t' 0 - z1 "
"d - 'Double_t' 0 - r2 d - 'Double_t' 0 - z2 "
"d - 'Double_t' 0 - phi1 d - 'Double_t' 0 - phi2", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t*, Double_t*, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t))(&TGeoConeSeg::DistToCons) ), 0);
   G__memfunc_setup("DistFromInsideS",1495,G__G__Geom1_213_0_13, 100, -1, G__defined_typename("Double_t"), 0, 14, 3, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - rmin1 "
"d - 'Double_t' 0 - rmax1 d - 'Double_t' 0 - rmin2 "
"d - 'Double_t' 0 - rmax2 d - 'Double_t' 0 - c1 "
"d - 'Double_t' 0 - s1 d - 'Double_t' 0 - c2 "
"d - 'Double_t' 0 - s2 d - 'Double_t' 0 - cm "
"d - 'Double_t' 0 - sm d - 'Double_t' 0 - cdfi", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t*, Double_t*, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t))(&TGeoConeSeg::DistFromInsideS) ), 0);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutsideS",1624,G__G__Geom1_213_0_15, 100, -1, G__defined_typename("Double_t"), 0, 14, 3, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - rmin1 "
"d - 'Double_t' 0 - rmax1 d - 'Double_t' 0 - rmin2 "
"d - 'Double_t' 0 - rmax2 d - 'Double_t' 0 - c1 "
"d - 'Double_t' 0 - s1 d - 'Double_t' 0 - c2 "
"d - 'Double_t' 0 - s2 d - 'Double_t' 0 - cm "
"d - 'Double_t' 0 - sm d - 'Double_t' 0 - cdfi", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t*, Double_t*, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t))(&TGeoConeSeg::DistFromOutsideS) ), 0);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisRange",1186,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - iaxis d - 'Double_t' 1 - xlo "
"d - 'Double_t' 1 - xhi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_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("GetByteCount",1213,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointsOnSegments",1952,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - npoints D - 'Double_t' 0 - array", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPhi1",626,G__G__Geom1_213_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhi2",627,G__G__Geom1_213_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeBuffer3D",1103,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TBuffer3D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SafetyS",703,G__G__Geom1_213_0_31, 100, -1, G__defined_typename("Double_t"), 0, 10, 3, 1, 0, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 - in "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - rmin1 "
"d - 'Double_t' 0 - rmax1 d - 'Double_t' 0 - rmin2 "
"d - 'Double_t' 0 - rmax2 d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - phi2 i - 'Int_t' 0 '0' skipz", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t*, Bool_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Double_t, Int_t))(&TGeoConeSeg::SafetyS) ), 0);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetConsDimensions",1752,G__G__Geom1_213_0_33, 121, -1, -1, 0, 7, 1, 1, 0, 
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - rmin1 "
"d - 'Double_t' 0 - rmax1 d - 'Double_t' 0 - rmin2 "
"d - 'Double_t' 0 - rmax2 d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - phi2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSegsAndPols",1391,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TBuffer3D' - 1 - buffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_213_0_39, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoConeSeg::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_213_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoConeSeg::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_213_0_41, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoConeSeg::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_213_0_42, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoConeSeg::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_213_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__Geom1_213_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoConeSeg::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_213_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoConeSeg::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_213_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoConeSeg::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_213_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoConeSeg::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoConeSeg", 1043, G__G__Geom1_213_0_51, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg), -1, 0, 1, 1, 1, 0, "u 'TGeoConeSeg' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoConeSeg", 1169, G__G__Geom1_213_0_52, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_213_0_53, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoConeSeg), -1, 1, 1, 1, 1, 0, "u 'TGeoConeSeg' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoPcon(void) {
   /* TGeoPcon */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon));
   G__memfunc_setup("TGeoPcon",767,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon), -1, 0, 1, 1, 2, 0, "u 'TGeoPcon' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon), -1, 1, 1, 1, 2, 0, "u 'TGeoPcon' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoPcon",767,G__G__Geom1_214_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoPcon",767,G__G__Geom1_214_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - phi d - 'Double_t' 0 - dphi "
"i - 'Int_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoPcon",767,G__G__Geom1_214_0_5, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - phi "
"d - 'Double_t' 0 - dphi i - 'Int_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoPcon",767,G__G__Geom1_214_0_6, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPcon), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefineSection",1312,G__G__Geom1_214_0_11, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - snum d - 'Double_t' 0 - z "
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistToSegZ",976,G__G__Geom1_214_0_14, 100, -1, G__defined_typename("Double_t"), 0, 10, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 1 - iz d - 'Double_t' 0 - c1 "
"d - 'Double_t' 0 - s1 d - 'Double_t' 0 - c2 "
"d - 'Double_t' 0 - s2 d - 'Double_t' 0 - cfio "
"d - 'Double_t' 0 - sfio d - 'Double_t' 0 - cdfi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisName",1078,(G__InterfaceMethod) NULL,67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - iaxis", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisRange",1186,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - iaxis d - 'Double_t' 1 - xlo "
"d - 'Double_t' 1 - xhi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_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("GetByteCount",1213,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPhi1",626,G__G__Geom1_214_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDphi",677,G__G__Geom1_214_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNz",488,G__G__Geom1_214_0_24, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNsegments",1236,G__G__Geom1_214_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRmin",694,G__G__Geom1_214_0_26, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRmin",694,G__G__Geom1_214_0_27, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - ipl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRmax",696,G__G__Geom1_214_0_28, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRmax",696,G__G__Geom1_214_0_29, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - ipl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZ",378,G__G__Geom1_214_0_30, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZ",378,G__G__Geom1_214_0_31, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - ipl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - - U 'TGeoMatrix' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointsOnSegments",1952,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - - D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCylType",902,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeBuffer3D",1103,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TBuffer3D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Phi1",338,G__G__Geom1_214_0_39, 100, -1, G__defined_typename("Double_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Dphi",389,G__G__Geom1_214_0_40, 100, -1, G__defined_typename("Double_t"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rmin",406,G__G__Geom1_214_0_41, 100, -1, G__defined_typename("Double_t"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - ipl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rmax",408,G__G__Geom1_214_0_42, 100, -1, G__defined_typename("Double_t"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - ipl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Z",90,G__G__Geom1_214_0_43, 100, -1, G__defined_typename("Double_t"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - ipl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SafetyToSegment",1538,G__G__Geom1_214_0_45, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 8, 
"D - 'Double_t' 0 - point i - 'Int_t' 0 - ipl "
"g - 'Bool_t' 0 'kTRUE' in d - 'Double_t' 0 'TGeoShape::Big()' safmin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSegsAndPols",1391,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TBuffer3D' - 1 - buff", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_214_0_52, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPcon::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_214_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPcon::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_214_0_54, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPcon::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_214_0_55, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPcon::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_214_0_59, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_214_0_60, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPcon::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_214_0_61, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPcon::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_214_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPcon::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_214_0_63, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPcon::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoPcon", 893, G__G__Geom1_214_0_64, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoPgon(void) {
   /* TGeoPgon */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon));
   G__memfunc_setup("GetPhiCrossList",1511,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 6, 1, 2, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 - istart D - 'Double_t' 0 - sphi "
"I - 'Int_t' 0 - iphi d - 'Double_t' 0 'TGeoShape::Big()' stepmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCrossingSlice",1524,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 7, 1, 2, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 - iphi d - 'Double_t' 0 - sstart "
"i - 'Int_t' 1 - ipl d - 'Double_t' 1 - snext "
"d - 'Double_t' 0 - stepmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LocatePhi",889,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"D - 'Double_t' 0 - point i - 'Int_t' 1 - ipsec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rpg",297,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 2, 8, 
"d - 'Double_t' 0 - z i - 'Int_t' 0 - ipl "
"g - 'Bool_t' 0 - inner d - 'Double_t' 1 - a "
"d - 'Double_t' 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rproj",525,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 7, 1, 2, 8, 
"d - 'Double_t' 0 - z D - 'Double_t' 0 - point "
"D - 'Double_t' 0 - dir d - 'Double_t' 0 - cphi "
"d - 'Double_t' 0 - sphi d - 'Double_t' 1 - a "
"d - 'Double_t' 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SliceCrossing",1336,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 7, 1, 2, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 - nphi I - 'Int_t' 0 - iphi "
"D - 'Double_t' 0 - sphi d - 'Double_t' 1 - snext "
"d - 'Double_t' 0 - stepmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SliceCrossingIn",1519,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 8, 1, 2, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 - ipl i - 'Int_t' 0 - nphi "
"I - 'Int_t' 0 - iphi D - 'Double_t' 0 - sphi "
"d - 'Double_t' 1 - snext d - 'Double_t' 0 - stepmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SliceCrossingZ",1426,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 7, 1, 2, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 - nphi I - 'Int_t' 0 - iphi "
"D - 'Double_t' 0 - sphi d - 'Double_t' 1 - snext "
"d - 'Double_t' 0 - stepmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SliceCrossingInZ",1609,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 7, 1, 2, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 - nphi I - 'Int_t' 0 - iphi "
"D - 'Double_t' 0 - sphi d - 'Double_t' 1 - snext "
"d - 'Double_t' 0 - stepmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoPgon",771,G__G__Geom1_215_0_10, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoPgon",771,G__G__Geom1_215_0_11, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - phi d - 'Double_t' 0 - dphi "
"i - 'Int_t' 0 - nedges i - 'Int_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoPgon",771,G__G__Geom1_215_0_12, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - phi "
"d - 'Double_t' 0 - dphi i - 'Int_t' 0 - nedges "
"i - 'Int_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoPgon",771,G__G__Geom1_215_0_13, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_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("GetByteCount",1213,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - - U 'TGeoMatrix' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNedges",886,G__G__Geom1_215_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNsegments",1236,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointsOnSegments",1952,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - npoints D - 'Double_t' 0 - array", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeBuffer3D",1103,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TBuffer3D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SafetyToSegment",1538,G__G__Geom1_215_0_34, 100, -1, G__defined_typename("Double_t"), 0, 6, 1, 1, 8, 
"D - 'Double_t' 0 - point i - 'Int_t' 0 - ipl "
"i - 'Int_t' 0 - iphi g - 'Bool_t' 0 - in "
"d - 'Double_t' 0 - safphi d - 'Double_t' 0 'TGeoShape::Big()' safmin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNedges",898,G__G__Geom1_215_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ne", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSegsAndPols",1391,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TBuffer3D' - 1 - buff", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_215_0_42, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPgon::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_215_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPgon::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_215_0_44, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPgon::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_215_0_45, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPgon::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_215_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_215_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPgon::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_215_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPgon::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_215_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPgon::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_215_0_53, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPgon::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoPgon", 771, G__G__Geom1_215_0_54, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoPgon), -1, 0, 1, 1, 1, 0, "u 'TGeoPgon' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoPgon", 897, G__G__Geom1_215_0_55, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoArb8(void) {
   /* TGeoArb8 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8));
   G__memfunc_setup("TGeoArb8",700,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8), -1, 0, 1, 1, 2, 0, "u 'TGeoArb8' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8), -1, 1, 1, 1, 2, 0, "u 'TGeoArb8' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoArb8",700,G__G__Geom1_216_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoArb8",700,G__G__Geom1_216_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8), -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - dz D - 'Double_t' 0 '0' vertices", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoArb8",700,G__G__Geom1_216_0_5, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoArb8), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - dz "
"D - 'Double_t' 0 '0' vertices", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ComputeTwist",1272,G__G__Geom1_216_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistToPlane",1095,G__G__Geom1_216_0_11, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 - ipl g - 'Bool_t' 0 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisRange",1186,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - iaxis d - 'Double_t' 1 - xlo "
"d - 'Double_t' 1 - xhi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetByteCount",1213,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetClosestEdge",1394,G__G__Geom1_216_0_18, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - vert "
"i - 'Int_t' 1 - isegment", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPointsOnFacet",1597,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDz",478,G__G__Geom1_216_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFittingBox",1310,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 8, 
"U 'TGeoBBox' - 10 - parambox U 'TGeoMatrix' - 0 - mat "
"d - 'Double_t' 1 - dx d - 'Double_t' 1 - dy "
"d - 'Double_t' 1 - dz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - - U 'TGeoMatrix' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPlaneNormal",1401,G__G__Geom1_216_0_23, 121, -1, -1, 0, 4, 3, 1, 0, 
"D - 'Double_t' 0 - p1 D - 'Double_t' 0 - p2 "
"D - 'Double_t' 0 - p3 D - 'Double_t' 0 - norm", (char*)NULL, (void*) G__func2void( (void (*)(Double_t*, Double_t*, Double_t*, Double_t*))(&TGeoArb8::GetPlaneNormal) ), 0);
   G__memfunc_setup("GetVertices",1125,G__G__Geom1_216_0_24, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTwist",827,G__G__Geom1_216_0_25, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - iseg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCylType",902,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSamePoint",1100,G__G__Geom1_216_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 2, 3, 1, 0, 
"D - 'Double_t' 0 - p1 D - 'Double_t' 0 - p2", (char*)NULL, (void*) G__func2void( (Bool_t (*)(Double_t*, Double_t*))(&TGeoArb8::IsSamePoint) ), 0);
   G__memfunc_setup("InsidePolygon",1348,G__G__Geom1_216_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 3, 3, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"D - 'Double_t' 0 - pts", (char*)NULL, (void*) G__func2void( (Bool_t (*)(Double_t, Double_t, Double_t*))(&TGeoArb8::InsidePolygon) ), 0);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsTwisted",928,G__G__Geom1_216_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SafetyToFace",1182,G__G__Geom1_216_0_31, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"D - 'Double_t' 0 - point i - 'Int_t' 0 - iseg "
"g - 'Bool_t' 0 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPlaneVertices",1633,G__G__Geom1_216_0_34, 121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 - zpl D - 'Double_t' 0 - vertices", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVertex",938,G__G__Geom1_216_0_35, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - vnum d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDz",490,G__G__Geom1_216_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_216_0_41, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoArb8::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_216_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoArb8::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_216_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoArb8::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_216_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoArb8::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_216_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__Geom1_216_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoArb8::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_216_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoArb8::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_216_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoArb8::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_216_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoArb8::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoArb8", 826, G__G__Geom1_216_0_53, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoTrap(void) {
   /* TGeoTrap */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap));
   G__memfunc_setup("TGeoTrap",774,G__G__Geom1_218_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTrap",774,G__G__Geom1_218_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - theta "
"d - 'Double_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTrap",774,G__G__Geom1_218_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap), -1, 0, 11, 1, 1, 0, 
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - theta "
"d - 'Double_t' 0 - phi d - 'Double_t' 0 - h1 "
"d - 'Double_t' 0 - bl1 d - 'Double_t' 0 - tl1 "
"d - 'Double_t' 0 - alpha1 d - 'Double_t' 0 - h2 "
"d - 'Double_t' 0 - bl2 d - 'Double_t' 0 - tl2 "
"d - 'Double_t' 0 - alpha2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTrap",774,G__G__Geom1_218_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap), -1, 0, 12, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - dz "
"d - 'Double_t' 0 - theta d - 'Double_t' 0 - phi "
"d - 'Double_t' 0 - h1 d - 'Double_t' 0 - bl1 "
"d - 'Double_t' 0 - tl1 d - 'Double_t' 0 - alpha1 "
"d - 'Double_t' 0 - h2 d - 'Double_t' 0 - bl2 "
"d - 'Double_t' 0 - tl2 d - 'Double_t' 0 - alpha2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTheta",790,G__G__Geom1_218_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhi",577,G__G__Geom1_218_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetH1",409,G__G__Geom1_218_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBl1",511,G__G__Geom1_218_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTl1",529,G__G__Geom1_218_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAlpha1",823,G__G__Geom1_218_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetH2",410,G__G__Geom1_218_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBl2",512,G__G__Geom1_218_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTl2",530,G__G__Geom1_218_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAlpha2",824,G__G__Geom1_218_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_218_0_22, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTrap::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_218_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrap::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_218_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTrap::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_218_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTrap::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_218_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__Geom1_218_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrap::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_218_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrap::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_218_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrap::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_218_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrap::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoTrap", 774, G__G__Geom1_218_0_34, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrap), -1, 0, 1, 1, 1, 0, "u 'TGeoTrap' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoTrap", 900, G__G__Geom1_218_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoGtra(void) {
   /* TGeoGtra */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra));
   G__memfunc_setup("TGeoGtra",765,G__G__Geom1_219_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoGtra",765,G__G__Geom1_219_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra), -1, 0, 12, 1, 1, 0, 
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - theta "
"d - 'Double_t' 0 - phi d - 'Double_t' 0 - twist "
"d - 'Double_t' 0 - h1 d - 'Double_t' 0 - bl1 "
"d - 'Double_t' 0 - tl1 d - 'Double_t' 0 - alpha1 "
"d - 'Double_t' 0 - h2 d - 'Double_t' 0 - bl2 "
"d - 'Double_t' 0 - tl2 d - 'Double_t' 0 - alpha2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoGtra",765,G__G__Geom1_219_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra), -1, 0, 13, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - dz "
"d - 'Double_t' 0 - theta d - 'Double_t' 0 - phi "
"d - 'Double_t' 0 - twist d - 'Double_t' 0 - h1 "
"d - 'Double_t' 0 - bl1 d - 'Double_t' 0 - tl1 "
"d - 'Double_t' 0 - alpha1 d - 'Double_t' 0 - h2 "
"d - 'Double_t' 0 - bl2 d - 'Double_t' 0 - tl2 "
"d - 'Double_t' 0 - alpha2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTwistAngle",1314,G__G__Geom1_219_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_219_0_10, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoGtra::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_219_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGtra::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_219_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoGtra::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_219_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoGtra::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_219_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__Geom1_219_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGtra::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_219_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoGtra::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_219_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGtra::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_219_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoGtra::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoGtra", 765, G__G__Geom1_219_0_22, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoGtra), -1, 0, 1, 1, 1, 0, "u 'TGeoGtra' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoGtra", 891, G__G__Geom1_219_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoTrd1(void) {
   /* TGeoTrd1 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1));
   G__memfunc_setup("TGeoTrd1",714,G__G__Geom1_220_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTrd1",714,G__G__Geom1_220_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1), -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - dx1 d - 'Double_t' 0 - dx2 "
"d - 'Double_t' 0 - dy d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTrd1",714,G__G__Geom1_220_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - dx1 "
"d - 'Double_t' 0 - dx2 d - 'Double_t' 0 - dy "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTrd1",714,G__G__Geom1_220_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisRange",1186,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - iaxis d - 'Double_t' 1 - xlo "
"d - 'Double_t' 1 - xhi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetByteCount",1213,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDx1",525,G__G__Geom1_220_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDx2",526,G__G__Geom1_220_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDy",477,G__G__Geom1_220_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDz",478,G__G__Geom1_220_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFittingBox",1310,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 8, 
"U 'TGeoBBox' - 10 - parambox U 'TGeoMatrix' - 0 - mat "
"d - 'Double_t' 1 - dx d - 'Double_t' 1 - dy "
"d - 'Double_t' 1 - dz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVisibleCorner",1623,G__G__Geom1_220_0_21, 121, -1, -1, 0, 3, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - vertex "
"D - 'Double_t' 0 - normals", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOppositeCorner",1756,G__G__Geom1_220_0_22, 121, -1, -1, 0, 4, 1, 1, 8, 
"D - 'Double_t' 0 - point i - 'Int_t' 0 - inorm "
"D - 'Double_t' 0 - vertex D - 'Double_t' 0 - normals", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCylType",902,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVertex",938,G__G__Geom1_220_0_30, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - vertex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_220_0_32, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTrd1::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_220_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd1::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_220_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTrd1::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_220_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTrd1::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_220_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_220_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd1::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_220_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrd1::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_220_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd1::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_220_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrd1::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoTrd1", 714, G__G__Geom1_220_0_44, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1), -1, 0, 1, 1, 1, 0, "u 'TGeoTrd1' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoTrd1", 840, G__G__Geom1_220_0_45, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_220_0_46, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd1), -1, 1, 1, 1, 1, 0, "u 'TGeoTrd1' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoTrd2(void) {
   /* TGeoTrd2 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2));
   G__memfunc_setup("TGeoTrd2",715,G__G__Geom1_221_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTrd2",715,G__G__Geom1_221_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2), -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 - dx1 d - 'Double_t' 0 - dx2 "
"d - 'Double_t' 0 - dy1 d - 'Double_t' 0 - dy2 "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTrd2",715,G__G__Geom1_221_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - dx1 "
"d - 'Double_t' 0 - dx2 d - 'Double_t' 0 - dy1 "
"d - 'Double_t' 0 - dy2 d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoTrd2",715,G__G__Geom1_221_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAxisRange",1186,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - iaxis d - 'Double_t' 1 - xlo "
"d - 'Double_t' 1 - xhi", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetByteCount",1213,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDx1",525,G__G__Geom1_221_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDx2",526,G__G__Geom1_221_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDy1",526,G__G__Geom1_221_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDy2",527,G__G__Geom1_221_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDz",478,G__G__Geom1_221_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFittingBox",1310,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 8, 
"U 'TGeoBBox' - 10 - parambox U 'TGeoMatrix' - 0 - mat "
"d - 'Double_t' 1 - dx d - 'Double_t' 1 - dy "
"d - 'Double_t' 1 - dz", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVisibleCorner",1623,G__G__Geom1_221_0_22, 121, -1, -1, 0, 3, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - vertex "
"D - 'Double_t' 0 - normals", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOppositeCorner",1756,G__G__Geom1_221_0_23, 121, -1, -1, 0, 4, 1, 1, 8, 
"D - 'Double_t' 0 - point i - 'Int_t' 0 - inorm "
"D - 'Double_t' 0 - vertex D - 'Double_t' 0 - normals", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCylType",902,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVertex",938,G__G__Geom1_221_0_31, 121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - vertex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_221_0_33, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTrd2::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_221_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd2::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_221_0_35, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTrd2::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_221_0_36, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTrd2::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_221_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_221_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd2::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_221_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrd2::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_221_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd2::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_221_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrd2::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoTrd2", 715, G__G__Geom1_221_0_45, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2), -1, 0, 1, 1, 1, 0, "u 'TGeoTrd2' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoTrd2", 841, G__G__Geom1_221_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_221_0_47, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoTrd2), -1, 1, 1, 1, 1, 0, "u 'TGeoTrd2' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoNavigator(void) {
   /* TGeoNavigator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoNavigator));
   G__memfunc_setup("TGeoNavigator",1306,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNavigator), -1, 0, 1, 1, 2, 0, "u 'TGeoNavigator' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNavigator), -1, 1, 1, 1, 2, 0, "u 'TGeoNavigator' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindInCluster",1306,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 2, 1, 2, 0, 
"I - 'Int_t' 0 - cluster i - 'Int_t' 0 - nc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTouchedCluster",1742,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0, 
"i - 'Int_t' 0 - start D - 'Double_t' 0 - point "
"I - 'Int_t' 0 - check_list i - 'Int_t' 0 - ncheck "
"I - 'Int_t' 0 - result", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CrossDivisionCell",1743,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SafetyOverlaps",1464,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoNavigator",1306,G__G__Geom1_224_0_7, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNavigator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoNavigator",1306,G__G__Geom1_224_0_8, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNavigator), -1, 0, 1, 1, 1, 0, "U 'TGeoManager' - 0 - geom", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildCache",964,G__G__Geom1_224_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kFALSE' dummy g - 'Bool_t' 0 'kFALSE' nodeid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("cd",199,G__G__Geom1_224_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 '\"\"' path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckPath",875,G__G__Geom1_224_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "C - - 10 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CdNode",557,G__G__Geom1_224_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nodeid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CdDown",575,G__G__Geom1_224_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CdUp",364,G__G__Geom1_224_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CdTop",474,G__G__Geom1_224_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CdNext",582,G__G__Geom1_224_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBranchNames",1378,G__G__Geom1_224_0_17, 121, -1, -1, 0, 1, 1, 1, 8, "I - 'Int_t' 0 - names", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBranchNumbers",1610,G__G__Geom1_224_0_18, 121, -1, -1, 0, 2, 1, 1, 8, 
"I - 'Int_t' 0 - copyNumbers I - 'Int_t' 0 - volumeNumbers", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBranchOnlys",1411,G__G__Geom1_224_0_19, 121, -1, -1, 0, 1, 1, 1, 8, "I - 'Int_t' 0 - isonly", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNmany",803,G__G__Geom1_224_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CrossBoundaryAndLocate",2233,G__G__Geom1_224_0_21, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - downwards U 'TGeoNode' - 0 - skipnode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNextBoundary",1636,G__G__Geom1_224_0_22, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 'TGeoShape::Big()' stepmax C - - 10 '\"\"' path "
"g - 'Bool_t' 0 'kFALSE' frombdr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNextDaughterBoundary",2456,G__G__Geom1_224_0_23, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 4, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 1 - idaughter g - 'Bool_t' 0 'kFALSE' compmatrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNextBoundaryAndStep",2323,G__G__Geom1_224_0_24, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 'TGeoShape::Big()' stepmax g - 'Bool_t' 0 'kFALSE' compsafe", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNode",775,G__G__Geom1_224_0_25, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' safe_start", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNode",775,G__G__Geom1_224_0_26, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNormal",1002,G__G__Geom1_224_0_27, 68, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' forward", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindNormalFast",1400,G__G__Geom1_224_0_28, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitTrack",905,G__G__Geom1_224_0_29, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - point D - 'Double_t' 10 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitTrack",905,G__G__Geom1_224_0_30, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 6, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - nx "
"d - 'Double_t' 0 - ny d - 'Double_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetState",1028,G__G__Geom1_224_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetAll",796,G__G__Geom1_224_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Safety",620,G__G__Geom1_224_0_33, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' inside", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SearchNode",988,G__G__Geom1_224_0_34, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kFALSE' downwards U 'TGeoNode' - 10 '0' skipnode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Step",412,G__G__Geom1_224_0_35, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' is_geom g - 'Bool_t' 0 'kTRUE' cross", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastPoint",1214,G__G__Geom1_224_0_36, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVirtualLevel",1535,G__G__Geom1_224_0_37, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GotoSafeLevel",1296,G__G__Geom1_224_0_38, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSafeLevel",1175,G__G__Geom1_224_0_39, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSafeDistance",1482,G__G__Geom1_224_0_40, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastSafety",1312,G__G__Geom1_224_0_41, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStep",700,G__G__Geom1_224_0_42, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InspectState",1239,G__G__Geom1_224_0_43, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSafeStep",983,G__G__Geom1_224_0_44, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 - proposed d - 'Double_t' 1 - newsafety", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSameLocation",1403,G__G__Geom1_224_0_45, 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 g - 'Bool_t' 0 'kFALSE' change", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSameLocation",1403,G__G__Geom1_224_0_46, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSamePoint",1100,G__G__Geom1_224_0_47, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 8, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsStartSafe",1097,G__G__Geom1_224_0_48, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStartSafe",1209,G__G__Geom1_224_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStep",712,G__G__Geom1_224_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCheckingOverlaps",1828,G__G__Geom1_224_0_51, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCurrentOverlapping",2086,G__G__Geom1_224_0_52, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEntering",1016,G__G__Geom1_224_0_53, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsExiting",916,G__G__Geom1_224_0_54, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsStepEntering",1428,G__G__Geom1_224_0_55, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsStepExiting",1328,G__G__Geom1_224_0_56, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOutside",921,G__G__Geom1_224_0_57, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOnBoundary",1213,G__G__Geom1_224_0_58, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsNullStep",1011,G__G__Geom1_224_0_59, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCheckingOverlaps",1940,G__G__Geom1_224_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOutside",1033,G__G__Geom1_224_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoBackupState",1290,G__G__Geom1_224_0_62, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRestoreState",1432,G__G__Geom1_224_0_63, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNodeId",851,G__G__Geom1_224_0_64, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNextNode",1093,G__G__Geom1_224_0_65, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMother",911,G__G__Geom1_224_0_66, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '1' up", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMotherMatrix",1540,G__G__Geom1_224_0_67, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '1' up", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHMatrix",989,G__G__Geom1_224_0_68, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentMatrix",1656,G__G__Geom1_224_0_69, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentNode",1417,G__G__Geom1_224_0_70, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentNodeId",1590,G__G__Geom1_224_0_71, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentPoint",1549,G__G__Geom1_224_0_72, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentDirection",1956,G__G__Geom1_224_0_73, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentVolume",1659,G__G__Geom1_224_0_74, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCldirChecked",1461,G__G__Geom1_224_0_75, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCldir",782,G__G__Geom1_224_0_76, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNormal",905,G__G__Geom1_224_0_77, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLevel",792,G__G__Geom1_224_0_78, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPath",685,G__G__Geom1_224_0_79, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStackLevel",1294,G__G__Geom1_224_0_80, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentPoint",1561,G__G__Geom1_224_0_81, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentPoint",1561,G__G__Geom1_224_0_82, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLastPoint",1226,G__G__Geom1_224_0_83, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentDirection",1968,G__G__Geom1_224_0_84, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 10 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentDirection",1968,G__G__Geom1_224_0_85, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - nx d - 'Double_t' 0 - ny "
"d - 'Double_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCldirChecked",1473,G__G__Geom1_224_0_86, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LocalToMaster",1306,G__G__Geom1_224_0_87, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LocalToMasterVect",1708,G__G__Geom1_224_0_88, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LocalToMasterBomb",1690,G__G__Geom1_224_0_89, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - local D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MasterToLocal",1306,G__G__Geom1_224_0_90, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MasterToLocalVect",1708,G__G__Geom1_224_0_91, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MasterToLocalBomb",1690,G__G__Geom1_224_0_92, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - local", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MasterToTop",1122,G__G__Geom1_224_0_93, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - master D - 'Double_t' 0 - top", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TopToMaster",1122,G__G__Geom1_224_0_94, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - 'Double_t' 10 - top D - 'Double_t' 0 - master", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCache",756,G__G__Geom1_224_0_95, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNodeCache), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PushPath",813,G__G__Geom1_224_0_96, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' startlevel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PopPath",700,G__G__Geom1_224_0_97, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PopPath",700,G__G__Geom1_224_0_98, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PushPoint",938,G__G__Geom1_224_0_99, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' startlevel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PopPoint",825,G__G__Geom1_224_0_100, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PopPoint",825,G__G__Geom1_224_0_101, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PopDummy",827,G__G__Geom1_224_0_102, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '9999' ipop", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_224_0_103, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoNavigator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_224_0_104, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNavigator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_224_0_105, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoNavigator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_224_0_106, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoNavigator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_224_0_110, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_224_0_111, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNavigator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_224_0_112, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoNavigator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_224_0_113, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNavigator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_224_0_114, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoNavigator::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoNavigator", 1432, G__G__Geom1_224_0_115, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualGeoTrack(void) {
   /* TVirtualGeoTrack */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack), -1, 1, 1, 1, 2, 0, "u 'TVirtualGeoTrack' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddDaughter",1085,G__G__Geom1_225_0_5, 85, G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - id i - 'Int_t' 0 - pdgcode "
"U 'TObject' - 0 '0' particle", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddDaughter",1085,G__G__Geom1_225_0_6, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TVirtualGeoTrack' - 0 - other", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddPoint",787,G__G__Geom1_225_0_7, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - y "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - t", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("FindTrackWithId",1471,G__G__Geom1_225_0_8, 85, G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetId",461,G__G__Geom1_225_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDaughterId",1281,G__G__Geom1_225_0_10, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetDaughter",1108,G__G__Geom1_225_0_11, 85, G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMother",911,G__G__Geom1_225_0_12, 85, G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMotherParticle",1731,G__G__Geom1_225_0_13, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNdaughters",1333,G__G__Geom1_225_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNpoints",1035,G__G__Geom1_225_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetParentId",1079,G__G__Geom1_225_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParticle",1108,G__G__Geom1_225_0_18, 85, G__get_linked_tagnum(&G__G__Geom1LN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPDG",507,G__G__Geom1_225_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastPoint",1214,G__G__Geom1_225_0_20, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 8, 
"d - 'Double_t' 1 - x d - 'Double_t' 1 - y "
"d - 'Double_t' 1 - z d - 'Double_t' 1 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFirstPoint",1330,G__G__Geom1_225_0_21, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastPoint",1214,G__G__Geom1_225_0_22, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPoint",810,G__G__Geom1_225_0_23, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 8, 
"i - 'Int_t' 0 - i d - 'Double_t' 1 - x "
"d - 'Double_t' 1 - y d - 'Double_t' 1 - z "
"d - 'Double_t' 1 - t", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetPoint",810,G__G__Geom1_225_0_24, 68, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("HasPoints",921,G__G__Geom1_225_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInTimeRange",1263,G__G__Geom1_225_0_26, 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, 3);
   G__memfunc_setup("PaintCollect",1218,G__G__Geom1_225_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - - D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintCollectTrack",1719,G__G__Geom1_225_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - - D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PaintTrack",1009,G__G__Geom1_225_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ResetTrack",1016,G__G__Geom1_225_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetName",685,G__G__Geom1_225_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParticle",1120,G__G__Geom1_225_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - particle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParent",918,G__G__Geom1_225_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualGeoTrack' - 0 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetId",473,G__G__Geom1_225_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPDG",519,G__G__Geom1_225_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - pdgcode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_225_0_37, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualGeoTrack::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_225_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualGeoTrack::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_225_0_39, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualGeoTrack::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_225_0_40, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualGeoTrack::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_225_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_225_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualGeoTrack::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_225_0_46, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualGeoTrack::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_225_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualGeoTrack::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_225_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualGeoTrack::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualGeoTrack", 1737, G__G__Geom1_225_0_49, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoPhysicalNode(void) {
   /* TGeoPhysicalNode */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode));
   G__memfunc_setup("TGeoPhysicalNode",1586,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode), -1, 0, 1, 1, 2, 0, "u 'TGeoPhysicalNode' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode), -1, 1, 1, 1, 2, 0, "u 'TGeoPhysicalNode' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAligned",992,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPath",697,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBranchAsState",1583,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoPhysicalNode",1586,G__G__Geom1_226_0_6, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoPhysicalNode",1586,G__G__Geom1_226_0_7, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode), -1, 0, 1, 1, 1, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Align",491,G__G__Geom1_226_0_8, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGeoMatrix' - 0 '0' newmat U 'TGeoShape' - 0 '0' newshape "
"g - 'Bool_t' 0 'kFALSE' check d - 'Double_t' 0 '0.001' ovlp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("cd",199,G__G__Geom1_226_0_9, 121, -1, -1, 0, 0, 1, 1, 8, "", (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("GetLevel",792,G__G__Geom1_226_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Geom1_226_0_12, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '-1' level", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOriginalMatrix",1738,G__G__Geom1_226_0_13, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMother",911,G__G__Geom1_226_0_14, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '1' levup", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNode",678,G__G__Geom1_226_0_15, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '-1' level", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetShape",785,G__G__Geom1_226_0_16, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '-1' level", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVolume",920,G__G__Geom1_226_0_17, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 '-1' level", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsAligned",880,G__G__Geom1_226_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVolAttributes",1556,G__G__Geom1_226_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisible",906,G__G__Geom1_226_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsVisibleFull",1309,G__G__Geom1_226_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Refresh",719,G__G__Geom1_226_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMatrixOrig",1330,G__G__Geom1_226_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoMatrix' - 10 - local", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIsVolAtt",1090,G__G__Geom1_226_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVisibility",1364,G__G__Geom1_226_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVisibleFull",1421,G__G__Geom1_226_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (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__Geom1_226_0_29, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPhysicalNode::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_226_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPhysicalNode::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_226_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPhysicalNode::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_226_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPhysicalNode::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_226_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__Geom1_226_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPhysicalNode::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_226_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPhysicalNode::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_226_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPhysicalNode::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_226_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPhysicalNode::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoPhysicalNode", 1712, G__G__Geom1_226_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoPNEntry(void) {
   /* TGeoPNEntry */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPNEntry));
   G__memfunc_setup("TGeoPNEntry",1055,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPNEntry), -1, 0, 1, 1, 2, 0, "u 'TGeoPNEntry' - 11 - pne", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPNEntry), -1, 1, 1, 1, 2, 0, "u 'TGeoPNEntry' - 11 - pne", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoPNEntry",1055,G__G__Geom1_227_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPNEntry), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoPNEntry",1055,G__G__Geom1_227_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPNEntry), -1, 0, 2, 1, 1, 0, 
"C - - 10 - unique_name C - - 10 - path", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPath",685,G__G__Geom1_227_0_5, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Geom1_227_0_6, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrixOrig",1318,G__G__Geom1_227_0_7, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGlobalOrig",1282,G__G__Geom1_227_0_8, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHMatrix), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPhysicalNode",1507,G__G__Geom1_227_0_9, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPhysicalNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMatrix",929,G__G__Geom1_227_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoHMatrix' - 10 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPhysicalNode",1519,G__G__Geom1_227_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoPhysicalNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_227_0_12, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPNEntry::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_227_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPNEntry::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_227_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPNEntry::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_227_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPNEntry::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_227_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__Geom1_227_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPNEntry::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_227_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPNEntry::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_227_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPNEntry::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_227_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPNEntry::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoPNEntry", 1181, G__G__Geom1_227_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVirtualGeoPainter(void) {
   /* TVirtualGeoPainter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPainter));
   G__memfunc_setup("AddSize3D",795,G__G__Geom1_228_0_2, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - numpoints i - 'Int_t' 0 - numsegs "
"i - 'Int_t' 0 - numpolys", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddTrack",766,G__G__Geom1_228_0_3, 85, G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoTrack), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - id i - 'Int_t' 0 - pdgcode "
"U 'TObject' - 0 - particle", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddTrackPoint",1288,G__G__Geom1_228_0_4, 121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - box "
"g - 'Bool_t' 0 'kFALSE' reset", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("BombTranslation",1551,G__G__Geom1_228_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - tr D - 'Double_t' 0 - bombtr", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CheckPoint",1000,G__G__Geom1_228_0_6, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 '0' x d - 'Double_t' 0 '0' y "
"d - 'Double_t' 0 '0' z C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CheckBoundaryErrors",1951,G__G__Geom1_228_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '1000000' ntracks d - 'Double_t' 0 '-1.' radius", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CheckBoundaryReference",2225,G__G__Geom1_228_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' icheck", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CheckGeometryFull",1725,G__G__Geom1_228_0_9, 121, -1, -1, 0, 4, 1, 1, 0, 
"g - 'Bool_t' 0 'kTRUE' checkoverlaps g - 'Bool_t' 0 'kTRUE' checkcrossings "
"i - 'Int_t' 0 '10000' nrays D - 'Double_t' 10 'NULL' vertex", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CheckGeometry",1322,G__G__Geom1_228_0_10, 121, -1, -1, 0, 4, 1, 1, 8, 
"i - 'Int_t' 0 - nrays d - 'Double_t' 0 - startx "
"d - 'Double_t' 0 - starty d - 'Double_t' 0 - startz", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CheckOverlaps",1322,G__G__Geom1_228_0_11, 121, -1, -1, 0, 3, 1, 1, 8, 
"U 'TGeoVolume' - 10 - vol d - 'Double_t' 0 '0.1' ovlp "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CountVisibleNodes",1744,G__G__Geom1_228_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DefaultAngles",1311,G__G__Geom1_228_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DefaultColors",1335,G__G__Geom1_228_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DistanceToPrimitiveVol",2264,G__G__Geom1_228_0_15, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TGeoVolume' - 0 - vol i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   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, 3);
   G__memfunc_setup("DrawBatemanSol",1396,G__G__Geom1_228_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGeoBatemanSol' - 0 - sol C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawShape",895,G__G__Geom1_228_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGeoShape' - 0 - shape C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawOnly",816,G__G__Geom1_228_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawOverlap",1127,G__G__Geom1_228_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - ovlp C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawCurrentPoint",1659,G__G__Geom1_228_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - color", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawPanel",894,G__G__Geom1_228_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawPath",795,G__G__Geom1_228_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DrawVolume",1030,G__G__Geom1_228_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGeoVolume' - 0 - vol C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("EditGeometry",1234,G__G__Geom1_228_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("EstimateCameraMove",1820,G__G__Geom1_228_0_26, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - - d - 'Double_t' 0 - - "
"D - 'Double_t' 0 - - D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteShapeEvent",1734,G__G__Geom1_228_0_27, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGeoShape' - 0 - shape i - 'Int_t' 0 - event "
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ExecuteManagerEvent",1936,G__G__Geom1_228_0_28, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGeoManager' - 0 - geom i - 'Int_t' 0 - event "
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ExecuteVolumeEvent",1869,G__G__Geom1_228_0_29, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TGeoVolume' - 0 - volume i - 'Int_t' 0 - event "
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetColor",799,G__G__Geom1_228_0_30, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - base f - 'Float_t' 0 - light", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetNsegments",1236,G__G__Geom1_228_0_31, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetBombFactors",1394,G__G__Geom1_228_0_32, 121, -1, -1, 0, 4, 1, 1, 8, 
"d - 'Double_t' 1 - bombx d - 'Double_t' 1 - bomby "
"d - 'Double_t' 1 - bombz d - 'Double_t' 1 - bombr", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetBombMode",1061,G__G__Geom1_228_0_33, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetDrawPath",1083,G__G__Geom1_228_0_34, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetDrawnVolume",1428,G__G__Geom1_228_0_35, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTopVolume",1227,G__G__Geom1_228_0_36, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetViewAngles",1301,G__G__Geom1_228_0_37, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 1 - - d - 'Double_t' 1 - - "
"d - 'Double_t' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetVisLevel",1098,G__G__Geom1_228_0_38, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetVisOption",1227,G__G__Geom1_228_0_39, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetVolumeInfo",1316,G__G__Geom1_228_0_40, 67, -1, -1, 0, 3, 1, 1, 9, 
"U 'TGeoVolume' - 10 - volume i - 'Int_t' 0 - px "
"i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GrabFocus",892,G__G__Geom1_228_0_41, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 '0' nfr d - 'Double_t' 0 '0' dlong "
"d - 'Double_t' 0 '0' dlat d - 'Double_t' 0 '0' dpsi", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetViewBox",996,G__G__Geom1_228_0_42, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsPaintingShape",1511,G__G__Geom1_228_0_43, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsRaytracing",1232,G__G__Geom1_228_0_44, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("IsExplodedView",1420,G__G__Geom1_228_0_45, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("LegoPlot",806,G__G__Geom1_228_0_46, 85, G__get_linked_tagnum(&G__G__Geom1LN_TH2F), -1, 0, 9, 1, 1, 0, 
"i - 'Int_t' 0 '60' ntheta d - 'Double_t' 0 '0.' themin "
"d - 'Double_t' 0 '180.' themax i - 'Int_t' 0 '90' nphi "
"d - 'Double_t' 0 '0.' phimin d - 'Double_t' 0 '360.' phimax "
"d - 'Double_t' 0 '0.' rmin d - 'Double_t' 0 '9999999' rmax "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ModifiedPad",1078,G__G__Geom1_228_0_47, 121, -1, -1, 0, 1, 1, 1, 8, "g - 'Bool_t' 0 'kFALSE' update", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("OpProgress",1044,G__G__Geom1_228_0_48, 121, -1, -1, 0, 6, 1, 1, 0, 
"C - - 10 - opname n - 'Long64_t' 0 - current "
"n - 'Long64_t' 0 - size U 'TStopwatch' - 0 '0' watch "
"g - 'Bool_t' 0 'kFALSE' last g - 'Bool_t' 0 'kFALSE' refresh", (char*)NULL, (void*) NULL, 3);
   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, 3);
   G__memfunc_setup("PaintNode",898,G__G__Geom1_228_0_50, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGeoNode' - 0 - node C - 'Option_t' 10 '\"\"' option "
"U 'TGeoMatrix' - 0 '0' global", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintShape",1005,G__G__Geom1_228_0_51, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TGeoShape' - 0 - shape C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintOverlap",1237,G__G__Geom1_228_0_52, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - ovlp C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PrintOverlaps",1369,G__G__Geom1_228_0_53, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PaintVolume",1140,G__G__Geom1_228_0_54, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGeoVolume' - 0 - vol C - 'Option_t' 10 '\"\"' option "
"U 'TGeoMatrix' - 0 '0' global", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("RandomPoints",1246,G__G__Geom1_228_0_55, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TGeoVolume' - 10 - vol i - 'Int_t' 0 - npoints "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("RandomRays",1024,G__G__Geom1_228_0_56, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - nrays d - 'Double_t' 0 - startx "
"d - 'Double_t' 0 - starty d - 'Double_t' 0 - startz", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Raytrace",827,G__G__Geom1_228_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SamplePoints",1247,G__G__Geom1_228_0_58, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoNode), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - npoints d - 'Double_t' 1 - dist "
"d - 'Double_t' 0 - epsil C - - 10 - g3path", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetBombFactors",1406,G__G__Geom1_228_0_59, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 '1.3' bombx d - 'Double_t' 0 '1.3' bomby "
"d - 'Double_t' 0 '1.3' bombz d - 'Double_t' 0 '1.3' bombr", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetClippingShape",1619,G__G__Geom1_228_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoShape' - 0 - shape", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetExplodedView",1532,G__G__Geom1_228_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' iopt", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetGeoManager",1282,G__G__Geom1_228_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoManager' - 0 - geom", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetIteratorPlugin",1765,G__G__Geom1_228_0_63, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoIteratorPlugin' - 0 - plugin", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetCheckedNode",1369,G__G__Geom1_228_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoNode' - 0 - node", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetNsegments",1248,G__G__Geom1_228_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '20' nseg", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetNmeshPoints",1444,G__G__Geom1_228_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - npoints", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetRaytracing",1344,G__G__Geom1_228_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GeoPainter",1006,G__G__Geom1_228_0_68, 85, G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPainter), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TVirtualGeoPainter* (*)())(&TVirtualGeoPainter::GeoPainter) ), 0);
   G__memfunc_setup("SetPainter",1023,G__G__Geom1_228_0_69, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TVirtualGeoPainter' - 10 - painter", (char*)NULL, (void*) G__func2void( (void (*)(const TVirtualGeoPainter*))(&TVirtualGeoPainter::SetPainter) ), 0);
   G__memfunc_setup("SetTopVisible",1325,G__G__Geom1_228_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' vis", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTopVolume",1239,G__G__Geom1_228_0_71, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetVisLevel",1110,G__G__Geom1_228_0_72, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '3' level", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetVisOption",1239,G__G__Geom1_228_0_73, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ShapeDistancetoPrimitive",2488,G__G__Geom1_228_0_74, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 8, 
"U 'TGeoShape' - 10 - shape i - 'Int_t' 0 - numpoints "
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Test",416,G__G__Geom1_228_0_75, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - npoints C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("TestOverlaps",1260,G__G__Geom1_228_0_76, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("TestVoxels",1057,G__G__Geom1_228_0_77, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("UnbombTranslation",1778,G__G__Geom1_228_0_78, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 10 - tr D - 'Double_t' 0 - bombtr", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Weight",616,G__G__Geom1_228_0_79, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - precision C - 'Option_t' 10 '\"v\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__Geom1_228_0_80, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualGeoPainter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_228_0_81, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualGeoPainter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_228_0_82, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualGeoPainter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_228_0_83, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualGeoPainter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_228_0_87, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_228_0_88, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualGeoPainter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_228_0_89, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualGeoPainter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_228_0_90, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualGeoPainter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_228_0_91, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualGeoPainter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TVirtualGeoPainter", 1959, G__G__Geom1_228_0_92, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_228_0_93, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TVirtualGeoPainter), -1, 1, 1, 1, 1, 0, "u 'TVirtualGeoPainter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoCompositeShape(void) {
   /* TGeoCompositeShape */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape));
   G__memfunc_setup("TGeoCompositeShape",1811,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape), -1, 0, 1, 1, 2, 0, "u 'TGeoCompositeShape' - 11 - gcs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape), -1, 1, 1, 1, 2, 0, "u 'TGeoCompositeShape' - 11 - gcs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoCompositeShape",1811,G__G__Geom1_230_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoCompositeShape",1811,G__G__Geom1_230_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name C - - 10 - expression", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoCompositeShape",1811,G__G__Geom1_230_0_5, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape), -1, 0, 1, 1, 1, 0, "C - - 10 - expression", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoCompositeShape",1811,G__G__Geom1_230_0_6, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoCompositeShape), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name U 'TGeoBoolNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBoolNode",1074,G__G__Geom1_230_0_15, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBoolNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - - U 'TGeoMatrix' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointsOnSegments",1952,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - - D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsComposite",1135,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCylType",902,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeNode",772,G__G__Geom1_230_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - expression", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PaintComposite",1455,G__G__Geom1_230_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RegisterYourself",1694,G__G__Geom1_230_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_230_0_33, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoCompositeShape::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_230_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCompositeShape::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_230_0_35, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoCompositeShape::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_230_0_36, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoCompositeShape::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_230_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_230_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCompositeShape::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_230_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCompositeShape::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_230_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCompositeShape::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_230_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCompositeShape::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoCompositeShape", 1937, G__G__Geom1_230_0_45, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoShapeAssembly(void) {
   /* TGeoShapeAssembly */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapeAssembly));
   G__memfunc_setup("TGeoShapeAssembly",1696,G__G__Geom1_231_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapeAssembly), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoShapeAssembly",1696,G__G__Geom1_231_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapeAssembly), -1, 0, 1, 1, 1, 0, "U 'TGeoVolumeAssembly' - 0 - vol", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsAssembly",1020,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCylType",902,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NeedsBBoxRecompute",1806,G__G__Geom1_231_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RecomputeBoxLast",1649,G__G__Geom1_231_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSegsAndPols",1391,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TBuffer3D' - 1 - buff", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_231_0_23, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoShapeAssembly::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_231_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoShapeAssembly::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_231_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoShapeAssembly::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_231_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoShapeAssembly::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_231_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__Geom1_231_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoShapeAssembly::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_231_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoShapeAssembly::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_231_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoShapeAssembly::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_231_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoShapeAssembly::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoShapeAssembly", 1696, G__G__Geom1_231_0_35, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapeAssembly), -1, 0, 1, 1, 1, 0, "u 'TGeoShapeAssembly' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoShapeAssembly", 1822, G__G__Geom1_231_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_231_0_37, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoShapeAssembly), -1, 1, 1, 1, 1, 0, "u 'TGeoShapeAssembly' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoScaledShape(void) {
   /* TGeoScaledShape */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoScaledShape));
   G__memfunc_setup("TGeoScaledShape",1452,G__G__Geom1_232_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoScaledShape), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoScaledShape",1452,G__G__Geom1_232_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoScaledShape), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name U 'TGeoShape' - 0 - shape "
"U 'TGeoScale' - 0 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoScaledShape",1452,G__G__Geom1_232_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoScaledShape), -1, 0, 2, 1, 1, 0, 
"U 'TGeoShape' - 0 - shape U 'TGeoScale' - 0 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_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("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetShape",785,G__G__Geom1_232_0_16, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScale",776,G__G__Geom1_232_0_17, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoScale), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCylType",902,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsReflected",1098,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeBuffer3D",1103,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TBuffer3D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeScaledShape",1467,G__G__Geom1_232_0_22, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 3, 3, 1, 0, 
"C - - 10 - name U 'TGeoShape' - 0 - shape "
"U 'TGeoScale' - 0 - scale", (char*)NULL, (void*) G__func2void( (TGeoShape* (*)(const char*, TGeoShape*, TGeoScale*))(&TGeoScaledShape::MakeScaledShape) ), 0);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetScale",788,G__G__Geom1_232_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoScale' - 0 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSegsAndPols",1391,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TBuffer3D' - 1 - buffer", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_232_0_29, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoScaledShape::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_232_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoScaledShape::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_232_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoScaledShape::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_232_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoScaledShape::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_232_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__Geom1_232_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoScaledShape::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_232_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoScaledShape::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_232_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoScaledShape::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_232_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoScaledShape::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoScaledShape", 1452, G__G__Geom1_232_0_41, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoScaledShape), -1, 0, 1, 1, 1, 0, "u 'TGeoScaledShape' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoScaledShape", 1578, G__G__Geom1_232_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_232_0_43, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoScaledShape), -1, 1, 1, 1, 1, 0, "u 'TGeoScaledShape' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoPolygon(void) {
   /* TGeoPolygon */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygon));
   G__memfunc_setup("ConvexCheck",1105,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", "force convexity checking", (void*) NULL, 0);
   G__memfunc_setup("IsSegConvex",1102,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 8, 
"i - 'Int_t' 0 - i1 i - 'Int_t' 0 '-1' i2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRightSided",1187,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 4, 8, 
"D - 'Double_t' 0 - point i - 'Int_t' 0 - ind1 "
"i - 'Int_t' 0 - ind2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OutscribedConvex",1671,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoPolygon",1111,G__G__Geom1_238_0_5, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygon), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoPolygon",1111,G__G__Geom1_238_0_6, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygon), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nvert", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Area",377,G__G__Geom1_238_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Contains",831,G__G__Geom1_238_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FinishPolygon",1353,G__G__Geom1_238_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNvert",815,G__G__Geom1_238_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX",376,G__G__Geom1_238_0_11, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY",377,G__G__Geom1_238_0_12, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsClockwise",1120,G__G__Geom1_238_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsConvex",815,G__G__Geom1_238_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFinished",998,G__G__Geom1_238_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsIllegalCheck",1364,G__G__Geom1_238_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Safety",620,G__G__Geom1_238_0_17, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point i - 'Int_t' 1 - isegment", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetConvex",927,G__G__Geom1_238_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXY",477,G__G__Geom1_238_0_19, 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("SetNextIndex",1219,G__G__Geom1_238_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_238_0_21, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPolygon::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_238_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPolygon::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_238_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPolygon::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_238_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPolygon::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_238_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__Geom1_238_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPolygon::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_238_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPolygon::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_238_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPolygon::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_238_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPolygon::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoPolygon", 1111, G__G__Geom1_238_0_33, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygon), -1, 0, 1, 1, 1, 0, "u 'TGeoPolygon' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoPolygon", 1237, G__G__Geom1_238_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_238_0_35, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoPolygon), -1, 1, 1, 1, 1, 0, "u 'TGeoPolygon' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoXtru(void) {
   /* TGeoXtru */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru));
   G__memfunc_setup("TGeoXtru",802,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru), -1, 0, 1, 1, 2, 0, "u 'TGeoXtru' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru), -1, 1, 1, 1, 2, 0, "u 'TGeoXtru' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistToPlane",1095,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 6, 1, 2, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 - iz i - 'Int_t' 0 - ivert "
"d - 'Double_t' 0 - stepmax g - 'Bool_t' 0 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlaneVertices",1621,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 8, 
"i - 'Int_t' 0 - iz i - 'Int_t' 0 - ivert "
"D - 'Double_t' 0 - vert", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPlaneNormal",1401,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"D - 'Double_t' 10 - vert D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsPointInsidePlane",1810,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 2, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - vert "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SafetyToSector",1439,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 2, 0, 
"D - 'Double_t' 0 - point i - 'Int_t' 0 - iz "
"d - 'Double_t' 0 - safmin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIz",495,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - iz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSeg",587,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - iseg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoXtru",802,G__G__Geom1_240_0_10, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoXtru",802,G__G__Geom1_240_0_11, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoXtru",802,G__G__Geom1_240_0_12, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoXtru), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DefinePolygon",1331,G__G__Geom1_240_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nvert D - 'Double_t' 10 - xv "
"D - 'Double_t' 10 - yv", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefineSection",1312,G__G__Geom1_240_0_18, 121, -1, -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - snum d - 'Double_t' 0 - z "
"d - 'Double_t' 0 '0.' x0 d - 'Double_t' 0 '0.' y0 "
"d - 'Double_t' 0 '1.' scale", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_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("GetNz",488,G__G__Geom1_240_0_23, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNvert",815,G__G__Geom1_240_0_24, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetX",376,G__G__Geom1_240_0_25, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetY",377,G__G__Geom1_240_0_26, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXOffset",991,G__G__Geom1_240_0_27, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYOffset",992,G__G__Geom1_240_0_28, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScale",776,G__G__Geom1_240_0_29, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZ",378,G__G__Geom1_240_0_30, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetZ",378,G__G__Geom1_240_0_31, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - ipl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - - U 'TGeoMatrix' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeBuffer3D",1103,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TBuffer3D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Z",90,G__G__Geom1_240_0_37, 100, -1, G__defined_typename("Double_t"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - ipl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetCurrentZ",1129,G__G__Geom1_240_0_40, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - z i - 'Int_t' 0 - iz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCurrentVertices",1876,G__G__Geom1_240_0_41, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x0 d - 'Double_t' 0 - y0 "
"d - 'Double_t' 0 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSegsAndPols",1391,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TBuffer3D' - 1 - buff", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_240_0_47, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoXtru::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_240_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoXtru::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_240_0_49, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoXtru::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_240_0_50, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoXtru::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_240_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_240_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoXtru::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_240_0_56, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoXtru::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_240_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoXtru::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_240_0_58, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoXtru::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoXtru", 928, G__G__Geom1_240_0_59, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoHelix(void) {
   /* TGeoHelix */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelix));
   G__memfunc_setup("TGeoHelix",873,G__G__Geom1_243_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelix), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoHelix",873,G__G__Geom1_243_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelix), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - curvature d - 'Double_t' 0 - step "
"i - 'Int_t' 0 '1' charge", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitPoint",926,G__G__Geom1_243_0_3, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x0 d - 'Double_t' 0 - y0 "
"d - 'Double_t' 0 - z0", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitPoint",926,G__G__Geom1_243_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitDirection",1333,G__G__Geom1_243_0_5, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - dirx d - 'Double_t' 0 - diry "
"d - 'Double_t' 0 - dirz g - 'Bool_t' 0 'kTRUE' is_normalized", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitDirection",1333,G__G__Geom1_243_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - dir g - 'Bool_t' 0 'kTRUE' is_normalized", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeSafeStep",1528,G__G__Geom1_243_0_7, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 '1E-6' epsil", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentPoint",1549,G__G__Geom1_243_0_8, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentDirection",1956,G__G__Geom1_243_0_9, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXYcurvature",1458,G__G__Geom1_243_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStep",700,G__G__Geom1_243_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTotalCurvature",1765,G__G__Geom1_243_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsRightHanded",1278,G__G__Geom1_243_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", "a positive charge in B field makes a left-handed helix", (void*) NULL, 0);
   G__memfunc_setup("ResetStep",927,G__G__Geom1_243_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StepToPlane",1103,G__G__Geom1_243_0_15, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCharge",886,G__G__Geom1_243_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - charge", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXYcurvature",1470,G__G__Geom1_243_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - curvature", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetField",784,G__G__Geom1_243_0_18, 121, -1, -1, 0, 4, 1, 1, 0, 
"d - 'Double_t' 0 - bx d - 'Double_t' 0 - by "
"d - 'Double_t' 0 - bz g - 'Bool_t' 0 'kTRUE' is_normalized", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHelixStep",1218,G__G__Geom1_243_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - hstep", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Step",412,G__G__Geom1_243_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateHelix",1117,G__G__Geom1_243_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_243_0_22, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoHelix::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_243_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHelix::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_243_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoHelix::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_243_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoHelix::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_243_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__Geom1_243_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHelix::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_243_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoHelix::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_243_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHelix::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_243_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoHelix::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoHelix", 873, G__G__Geom1_243_0_34, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelix), -1, 0, 1, 1, 1, 0, "u 'TGeoHelix' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoHelix", 999, G__G__Geom1_243_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_243_0_36, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoHelix), -1, 1, 1, 1, 1, 0, "u 'TGeoHelix' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoParaboloid(void) {
   /* TGeoParaboloid */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid));
   G__memfunc_setup("TGeoParaboloid",1388,G__G__Geom1_245_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoParaboloid",1388,G__G__Geom1_245_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - rlo d - 'Double_t' 0 - rhi "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoParaboloid",1388,G__G__Geom1_245_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - rlo "
"d - 'Double_t' 0 - rhi d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoParaboloid",1388,G__G__Geom1_245_0_4, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistToParaboloid",1620,G__G__Geom1_245_0_10, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBuffer3D",1009,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Geom1LN_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("GetRlo",589,G__G__Geom1_245_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRhi",579,G__G__Geom1_245_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDz",478,G__G__Geom1_245_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - mother U 'TGeoMatrix' - 0 - mat", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPointsOnSegments",1952,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - - D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCylType",902,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeBuffer3D",1103,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TBuffer3D), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParaboloidDimensions",2370,G__G__Geom1_245_0_28, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - rlo d - 'Double_t' 0 - rhi "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - points", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSegsAndPols",1391,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TBuffer3D' - 1 - buff", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_245_0_34, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoParaboloid::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_245_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoParaboloid::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_245_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoParaboloid::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_245_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoParaboloid::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_245_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__Geom1_245_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoParaboloid::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_245_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoParaboloid::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_245_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoParaboloid::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_245_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoParaboloid::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoParaboloid", 1388, G__G__Geom1_245_0_46, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid), -1, 0, 1, 1, 1, 0, "u 'TGeoParaboloid' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoParaboloid", 1514, G__G__Geom1_245_0_47, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_245_0_48, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoParaboloid), -1, 1, 1, 1, 1, 0, "u 'TGeoParaboloid' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoHalfSpace(void) {
   /* TGeoHalfSpace */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace));
   G__memfunc_setup("TGeoHalfSpace",1238,G__G__Geom1_246_0_1, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoHalfSpace",1238,G__G__Geom1_246_0_2, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name D - 'Double_t' 0 - p "
"D - 'Double_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoHalfSpace",1238,G__G__Geom1_246_0_3, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace), -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Capacity",814,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (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("ComputeNormal",1350,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"D - 'Double_t' 0 - norm", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contains",831,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "D - 'Double_t' 0 - point", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistancetoPrimitive",1991,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - px i - 'Int_t' 0 - py", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromInside",1412,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DistFromOutside",1541,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 5, 1, 1, 8, 
"D - 'Double_t' 0 - point D - 'Double_t' 0 - dir "
"i - 'Int_t' 0 '1' iact d - 'Double_t' 0 'TGeoShape::Big()' step "
"D - 'Double_t' 0 '0' safe", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"U 'TGeoVolume' - 0 - voldiv C - - 10 - divname "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetPoint",810,G__G__Geom1_246_0_12, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNorm",700,G__G__Geom1_246_0_13, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBoundingCylinder",1936,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMakeRuntimeShape",1907,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoShape), -1, 0, 2, 1, 1, 8, 
"U 'TGeoShape' - 0 - - U 'TGeoMatrix' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMeshNumbers",1417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 1 - nvert i - 'Int_t' 1 - nsegs "
"i - 'Int_t' 1 - npols", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNmeshVertices",1632,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InspectShape",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsCylType",902,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Safety",620,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"D - 'Double_t' 0 - point g - 'Bool_t' 0 'kTRUE' in", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDimensions",1349,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - 'Double_t' 0 - param", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetPoints",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "F - 'Float_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sizeof3D",743,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Geom1_246_0_26, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoHalfSpace::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_246_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHalfSpace::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_246_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoHalfSpace::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_246_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoHalfSpace::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_246_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_246_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHalfSpace::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_246_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoHalfSpace::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_246_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHalfSpace::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_246_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoHalfSpace::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TGeoHalfSpace", 1238, G__G__Geom1_246_0_38, (int) ('i'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace), -1, 0, 1, 1, 1, 0, "u 'TGeoHalfSpace' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TGeoHalfSpace", 1364, G__G__Geom1_246_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Geom1_246_0_40, (int) ('u'), G__get_linked_tagnum(&G__G__Geom1LN_TGeoHalfSpace), -1, 1, 1, 1, 1, 0, "u 'TGeoHalfSpace' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTGeoBuilder(void) {
   /* TGeoBuilder */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Geom1LN_TGeoBuilder));
   G__memfunc_setup("TGeoBuilder",1078,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBuilder), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TGeoBuilder",1078,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBuilder), -1, 0, 1, 1, 2, 0, "u 'TGeoBuilder' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBuilder), -1, 1, 1, 1, 2, 0, "u 'TGeoBuilder' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGeometry",1144,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGeoManager' - 0 - geom", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Instance",821,G__G__Geom1_247_0_5, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoBuilder), -1, 0, 1, 3, 1, 0, "U 'TGeoManager' - 0 - geom", (char*)NULL, (void*) G__func2void( (TGeoBuilder* (*)(TGeoManager*))(&TGeoBuilder::Instance) ), 0);
   G__memfunc_setup("AddMaterial",1080,G__G__Geom1_247_0_6, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGeoMaterial' - 0 - material", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTransformation",1760,G__G__Geom1_247_0_7, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGeoMatrix' - 0 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddShape",762,G__G__Geom1_247_0_8, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TGeoShape' - 0 - shape", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegisterMatrix",1466,G__G__Geom1_247_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoMatrix' - 0 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeArb8",715,G__G__Geom1_247_0_10, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 4, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dz D - 'Double_t' 0 '0' vertices", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeBox",679,G__G__Geom1_247_0_11, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dx d - 'Double_t' 0 - dy "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeCone",771,G__G__Geom1_247_0_12, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - rmin1 "
"d - 'Double_t' 0 - rmax1 d - 'Double_t' 0 - rmin2 "
"d - 'Double_t' 0 - rmax2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeCons",785,G__G__Geom1_247_0_13, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 9, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - rmin1 "
"d - 'Double_t' 0 - rmax1 d - 'Double_t' 0 - rmin2 "
"d - 'Double_t' 0 - rmax2 d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - phi2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeCtub",780,G__G__Geom1_247_0_14, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 13, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - phi2 d - 'Double_t' 0 - lx "
"d - 'Double_t' 0 - ly d - 'Double_t' 0 - lz "
"d - 'Double_t' 0 - tx d - 'Double_t' 0 - ty "
"d - 'Double_t' 0 - tz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEltu",792,G__G__Geom1_247_0_15, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - a d - 'Double_t' 0 - b "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeGtra",780,G__G__Geom1_247_0_16, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 14, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - theta "
"d - 'Double_t' 0 - phi d - 'Double_t' 0 - twist "
"d - 'Double_t' 0 - h1 d - 'Double_t' 0 - bl1 "
"d - 'Double_t' 0 - tl1 d - 'Double_t' 0 - alpha1 "
"d - 'Double_t' 0 - h2 d - 'Double_t' 0 - bl2 "
"d - 'Double_t' 0 - tl2 d - 'Double_t' 0 - alpha2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakePara",770,G__G__Geom1_247_0_17, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dx d - 'Double_t' 0 - dy "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - alpha "
"d - 'Double_t' 0 - theta d - 'Double_t' 0 - phi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakePcon",782,G__G__Geom1_247_0_18, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - phi d - 'Double_t' 0 - dphi "
"i - 'Int_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeParaboloid",1403,G__G__Geom1_247_0_19, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - rlo d - 'Double_t' 0 - rhi "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeHype",788,G__G__Geom1_247_0_20, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - rin d - 'Double_t' 0 - stin "
"d - 'Double_t' 0 - rout d - 'Double_t' 0 - stout "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakePgon",786,G__G__Geom1_247_0_21, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - phi d - 'Double_t' 0 - dphi "
"i - 'Int_t' 0 - nedges i - 'Int_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeSphere",997,G__G__Geom1_247_0_22, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 '0' themin d - 'Double_t' 0 '180' themax "
"d - 'Double_t' 0 '0' phimin d - 'Double_t' 0 '360' phimax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTorus",923,G__G__Geom1_247_0_23, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - r d - 'Double_t' 0 - rmin "
"d - 'Double_t' 0 - rmax d - 'Double_t' 0 '0' phi1 "
"d - 'Double_t' 0 '360' dphi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTrap",789,G__G__Geom1_247_0_24, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 13, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - theta "
"d - 'Double_t' 0 - phi d - 'Double_t' 0 - h1 "
"d - 'Double_t' 0 - bl1 d - 'Double_t' 0 - tl1 "
"d - 'Double_t' 0 - alpha1 d - 'Double_t' 0 - h2 "
"d - 'Double_t' 0 - bl2 d - 'Double_t' 0 - tl2 "
"d - 'Double_t' 0 - alpha2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTrd1",729,G__G__Geom1_247_0_25, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 6, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dx1 d - 'Double_t' 0 - dx2 "
"d - 'Double_t' 0 - dy d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTrd2",730,G__G__Geom1_247_0_26, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - dx1 d - 'Double_t' 0 - dx2 "
"d - 'Double_t' 0 - dy1 d - 'Double_t' 0 - dy2 "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTube",782,G__G__Geom1_247_0_27, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeTubs",796,G__G__Geom1_247_0_28, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax "
"d - 'Double_t' 0 - dz d - 'Double_t' 0 - phi1 "
"d - 'Double_t' 0 - phi2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeXtru",817,G__G__Geom1_247_0_29, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 3, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium "
"i - 'Int_t' 0 - nz", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeVolumeAssembly",1846,G__G__Geom1_247_0_30, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeAssembly), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeVolumeMulti",1537,G__G__Geom1_247_0_31, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolumeMulti), -1, 0, 2, 1, 1, 0, 
"C - - 10 - name U 'TGeoMedium' - 0 - medium", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Division",837,G__G__Geom1_247_0_32, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 8, 1, 1, 0, 
"C - - 10 - name C - - 10 - mother "
"i - 'Int_t' 0 - iaxis i - 'Int_t' 0 - ndiv "
"d - 'Double_t' 0 - start d - 'Double_t' 0 - step "
"i - 'Int_t' 0 '0' numed C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Matrix",629,G__G__Geom1_247_0_33, 121, -1, -1, 0, 7, 1, 1, 0, 
"i - 'Int_t' 0 - index d - 'Double_t' 0 - theta1 "
"d - 'Double_t' 0 - phi1 d - 'Double_t' 0 - theta2 "
"d - 'Double_t' 0 - phi2 d - 'Double_t' 0 - theta3 "
"d - 'Double_t' 0 - phi3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Material",815,G__G__Geom1_247_0_34, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name d - 'Double_t' 0 - a "
"d - 'Double_t' 0 - z d - 'Double_t' 0 - dens "
"i - 'Int_t' 0 - uid d - 'Double_t' 0 '0' radlen "
"d - 'Double_t' 0 '0' intlen", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mixture",750,G__G__Geom1_247_0_35, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name F - 'Float_t' 0 - a "
"F - 'Float_t' 0 - z d - 'Double_t' 0 - dens "
"i - 'Int_t' 0 - nelem F - 'Float_t' 0 - wmat "
"i - 'Int_t' 0 - uid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mixture",750,G__G__Geom1_247_0_36, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMaterial), -1, 0, 7, 1, 1, 0, 
"C - - 10 - name D - 'Double_t' 0 - a "
"D - 'Double_t' 0 - z d - 'Double_t' 0 - dens "
"i - 'Int_t' 0 - nelem D - 'Double_t' 0 - wmat "
"i - 'Int_t' 0 - uid", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Medium",609,G__G__Geom1_247_0_37, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoMedium), -1, 0, 11, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - numed "
"i - 'Int_t' 0 - nmat i - 'Int_t' 0 - isvol "
"i - 'Int_t' 0 - ifield d - 'Double_t' 0 - fieldm "
"d - 'Double_t' 0 - tmaxfd d - 'Double_t' 0 - stemax "
"d - 'Double_t' 0 - deemax d - 'Double_t' 0 - epsil "
"d - 'Double_t' 0 - stmin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Node",390,G__G__Geom1_247_0_38, 121, -1, -1, 0, 10, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - nr "
"C - - 10 - mother d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y d - 'Double_t' 0 - z "
"i - 'Int_t' 0 - irot g - 'Bool_t' 0 - isOnly "
"F - 'Float_t' 0 - upar i - 'Int_t' 0 '0' npar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Node",390,G__G__Geom1_247_0_39, 121, -1, -1, 0, 10, 1, 1, 0, 
"C - - 10 - name i - 'Int_t' 0 - nr "
"C - - 10 - mother d - 'Double_t' 0 - x "
"d - 'Double_t' 0 - y d - 'Double_t' 0 - z "
"i - 'Int_t' 0 - irot g - 'Bool_t' 0 - isOnly "
"D - 'Double_t' 0 - upar i - 'Int_t' 0 '0' npar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Volume",632,G__G__Geom1_247_0_40, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - shape "
"i - 'Int_t' 0 - nmed F - 'Float_t' 0 - upar "
"i - 'Int_t' 0 '0' npar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Volume",632,G__G__Geom1_247_0_41, 85, G__get_linked_tagnum(&G__G__Geom1LN_TGeoVolume), -1, 0, 5, 1, 1, 0, 
"C - - 10 - name C - - 10 - shape "
"i - 'Int_t' 0 - nmed D - 'Double_t' 0 - upar "
"i - 'Int_t' 0 '0' npar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Geom1_247_0_42, 85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoBuilder::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Geom1_247_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBuilder::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Geom1_247_0_44, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoBuilder::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Geom1_247_0_45, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoBuilder::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Geom1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Geom1_247_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Geom1_247_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBuilder::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Geom1_247_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoBuilder::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Geom1_247_0_52, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBuilder::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Geom1_247_0_53, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoBuilder::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TGeoBuilder", 1204, G__G__Geom1_247_0_54, (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__Geom1() {
}

/*********************************************************
* 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() {
   G__memvar_setup((void*)(&gGeoIdentity),85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoIdentity),-1,-1,1,"gGeoIdentity=",0,(char*)NULL);
   G__memvar_setup((void*)(&gGeoManager),85,0,0,G__get_linked_tagnum(&G__G__Geom1LN_TGeoManager),-1,-1,1,"gGeoManager=",0,(char*)NULL);

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Geom1() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Geom1() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__Geom1LN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TBrowser = { "TBrowser" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoAtt = { "TGeoAtt" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoAttcLcLdA = { "TGeoAtt::$" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt = { "TGeoAtt::EGeoVisibilityAtt" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoAttcLcLEGeoActivityAtt = { "TGeoAtt::EGeoActivityAtt" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoAttcLcLEGeoOptimizationAtt = { "TGeoAtt::EGeoOptimizationAtt" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoAttcLcLEGeoSavePrimitiveAtt = { "TGeoAtt::EGeoSavePrimitiveAtt" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoShape = { "TGeoShape" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoMatrix = { "TGeoMatrix" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoHMatrix = { "TGeoHMatrix" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoBoolNode = { "TGeoBoolNode" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoBoolNodecLcLEGeoBoolType = { "TGeoBoolNode::EGeoBoolType" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoUnion = { "TGeoUnion" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoIntersection = { "TGeoIntersection" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoSubtraction = { "TGeoSubtraction" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TAttFill = { "TAttFill" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TAttLine = { "TAttLine" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TAttMarker = { "TAttMarker" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoElementTable = { "TGeoElementTable" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoIsotope = { "TGeoIsotope" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoElement = { "TGeoElement" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoElementcLcLEGeoElement = { "TGeoElement::EGeoElement" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoDecayChannel = { "TGeoDecayChannel" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoBatemanSol = { "TGeoBatemanSol" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoElementRN = { "TGeoElementRN" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode = { "TGeoDecayChannel::ENuclearDecayMode" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoBatemanSolcLcLBtCoef_t = { "TGeoBatemanSol::BtCoef_t" , 115 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoElemIter = { "TGeoElemIter" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR = { "map<int,TGeoElementRN*,less<int>,allocator<pair<const int,TGeoElementRN*> > >" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgRcLcLiterator = { "map<int,TGeoElementRN*,less<int>,allocator<pair<const int,TGeoElementRN*> > >::iterator" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoElementTablecLcLEGeoETStatus = { "TGeoElementTable::EGeoETStatus" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoMaterial = { "TGeoMaterial" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterial = { "TGeoMaterial::EGeoMaterial" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterialState = { "TGeoMaterial::EGeoMaterialState" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoMixture = { "TGeoMixture" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoMedium = { "TGeoMedium" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoMediumcLcLEGeoMedium = { "TGeoMedium::EGeoMedium" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes = { "TGeoMatrix::EGeoTransfTypes" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoTranslation = { "TGeoTranslation" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoRotation = { "TGeoRotation" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoScale = { "TGeoScale" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoCombiTrans = { "TGeoCombiTrans" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoGenTrans = { "TGeoGenTrans" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoIdentity = { "TGeoIdentity" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TAtt3D = { "TAtt3D" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoBBox = { "TGeoBBox" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoVolume = { "TGeoVolume" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TBuffer3D = { "TBuffer3D" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoShapecLcLEShapeType = { "TGeoShape::EShapeType" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TH2F = { "TH2F" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoNode = { "TGeoNode" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoPatternFinder = { "TGeoPatternFinder" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoVoxelFinder = { "TGeoVoxelFinder" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoManager = { "TGeoManager" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes = { "TGeoVolume::EGeoVolumeTypes" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoVolumeMulti = { "TGeoVolumeMulti" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoVolumeAssembly = { "TGeoVolumeAssembly" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoNodecLcLdA = { "TGeoNode::$" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoNodeMatrix = { "TGeoNodeMatrix" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoNodeOffset = { "TGeoNodeOffset" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoIterator = { "TGeoIterator" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoIteratorPlugin = { "TGeoIteratorPlugin" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoVoxelFindercLcLEVoxelsType = { "TGeoVoxelFinder::EVoxelsType" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoPara = { "TGeoPara" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoTube = { "TGeoTube" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoTubeSeg = { "TGeoTubeSeg" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoCtub = { "TGeoCtub" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoTorus = { "TGeoTorus" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoSphere = { "TGeoSphere" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoEltu = { "TGeoEltu" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoHype = { "TGeoHype" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoCone = { "TGeoCone" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoConeSeg = { "TGeoConeSeg" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoPcon = { "TGeoPcon" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoPgon = { "TGeoPgon" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoArb8 = { "TGeoArb8" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoArb8cLcLEGeoArb8Type = { "TGeoArb8::EGeoArb8Type" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoTrap = { "TGeoTrap" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoGtra = { "TGeoGtra" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoTrd1 = { "TGeoTrd1" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoTrd2 = { "TGeoTrd2" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoCacheState = { "TGeoCacheState" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoNodeCache = { "TGeoNodeCache" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoNavigator = { "TGeoNavigator" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TVirtualGeoTrack = { "TVirtualGeoTrack" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoPhysicalNode = { "TGeoPhysicalNode" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoPNEntry = { "TGeoPNEntry" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TVirtualGeoPainter = { "TVirtualGeoPainter" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_THashList = { "THashList" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoCompositeShape = { "TGeoCompositeShape" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoShapeAssembly = { "TGeoShapeAssembly" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoScaledShape = { "TGeoScaledShape" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TStopwatch = { "TStopwatch" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisLevel = { "TVirtualGeoPainter::EGeoVisLevel" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisOption = { "TVirtualGeoPainter::EGeoVisOption" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoBombOption = { "TVirtualGeoPainter::EGeoBombOption" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoPolygon = { "TGeoPolygon" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoPolygoncLcLdA = { "TGeoPolygon::$" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoXtru = { "TGeoXtru" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoPhysicalNodecLcLdA = { "TGeoPhysicalNode::$" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoPNEntrycLcLEPNEntryFlags = { "TGeoPNEntry::EPNEntryFlags" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoHelix = { "TGeoHelix" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoHelixcLcLEGeoHelixTypes = { "TGeoHelix::EGeoHelixTypes" , 101 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoParaboloid = { "TGeoParaboloid" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoHalfSpace = { "TGeoHalfSpace" , 99 , -1 };
G__linked_taginfo G__G__Geom1LN_TGeoBuilder = { "TGeoBuilder" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Geom1() {
  G__G__Geom1LN_TClass.tagnum = -1 ;
  G__G__Geom1LN_TBuffer.tagnum = -1 ;
  G__G__Geom1LN_TMemberInspector.tagnum = -1 ;
  G__G__Geom1LN_TObject.tagnum = -1 ;
  G__G__Geom1LN_TNamed.tagnum = -1 ;
  G__G__Geom1LN_TString.tagnum = -1 ;
  G__G__Geom1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__Geom1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__Geom1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Geom1LN_TList.tagnum = -1 ;
  G__G__Geom1LN_TBrowser.tagnum = -1 ;
  G__G__Geom1LN_TObjArray.tagnum = -1 ;
  G__G__Geom1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__Geom1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Geom1LN_TGeoAtt.tagnum = -1 ;
  G__G__Geom1LN_TGeoAttcLcLdA.tagnum = -1 ;
  G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt.tagnum = -1 ;
  G__G__Geom1LN_TGeoAttcLcLEGeoActivityAtt.tagnum = -1 ;
  G__G__Geom1LN_TGeoAttcLcLEGeoOptimizationAtt.tagnum = -1 ;
  G__G__Geom1LN_TGeoAttcLcLEGeoSavePrimitiveAtt.tagnum = -1 ;
  G__G__Geom1LN_TGeoShape.tagnum = -1 ;
  G__G__Geom1LN_TGeoMatrix.tagnum = -1 ;
  G__G__Geom1LN_TGeoHMatrix.tagnum = -1 ;
  G__G__Geom1LN_TGeoBoolNode.tagnum = -1 ;
  G__G__Geom1LN_TGeoBoolNodecLcLEGeoBoolType.tagnum = -1 ;
  G__G__Geom1LN_TGeoUnion.tagnum = -1 ;
  G__G__Geom1LN_TGeoIntersection.tagnum = -1 ;
  G__G__Geom1LN_TGeoSubtraction.tagnum = -1 ;
  G__G__Geom1LN_TAttFill.tagnum = -1 ;
  G__G__Geom1LN_TAttLine.tagnum = -1 ;
  G__G__Geom1LN_TAttMarker.tagnum = -1 ;
  G__G__Geom1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__Geom1LN_TGeoElementTable.tagnum = -1 ;
  G__G__Geom1LN_TGeoIsotope.tagnum = -1 ;
  G__G__Geom1LN_TGeoElement.tagnum = -1 ;
  G__G__Geom1LN_TGeoElementcLcLEGeoElement.tagnum = -1 ;
  G__G__Geom1LN_TGeoDecayChannel.tagnum = -1 ;
  G__G__Geom1LN_TGeoBatemanSol.tagnum = -1 ;
  G__G__Geom1LN_TGeoElementRN.tagnum = -1 ;
  G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode.tagnum = -1 ;
  G__G__Geom1LN_TGeoBatemanSolcLcLBtCoef_t.tagnum = -1 ;
  G__G__Geom1LN_TGeoElemIter.tagnum = -1 ;
  G__G__Geom1LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR.tagnum = -1 ;
  G__G__Geom1LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__Geom1LN_TGeoElementTablecLcLEGeoETStatus.tagnum = -1 ;
  G__G__Geom1LN_TGeoMaterial.tagnum = -1 ;
  G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterial.tagnum = -1 ;
  G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterialState.tagnum = -1 ;
  G__G__Geom1LN_TGeoMixture.tagnum = -1 ;
  G__G__Geom1LN_TGeoMedium.tagnum = -1 ;
  G__G__Geom1LN_TGeoMediumcLcLEGeoMedium.tagnum = -1 ;
  G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes.tagnum = -1 ;
  G__G__Geom1LN_TGeoTranslation.tagnum = -1 ;
  G__G__Geom1LN_TGeoRotation.tagnum = -1 ;
  G__G__Geom1LN_TGeoScale.tagnum = -1 ;
  G__G__Geom1LN_TGeoCombiTrans.tagnum = -1 ;
  G__G__Geom1LN_TGeoGenTrans.tagnum = -1 ;
  G__G__Geom1LN_TGeoIdentity.tagnum = -1 ;
  G__G__Geom1LN_TAtt3D.tagnum = -1 ;
  G__G__Geom1LN_TGeoBBox.tagnum = -1 ;
  G__G__Geom1LN_TGeoVolume.tagnum = -1 ;
  G__G__Geom1LN_TBuffer3D.tagnum = -1 ;
  G__G__Geom1LN_TGeoShapecLcLEShapeType.tagnum = -1 ;
  G__G__Geom1LN_TH2F.tagnum = -1 ;
  G__G__Geom1LN_TGeoNode.tagnum = -1 ;
  G__G__Geom1LN_TGeoPatternFinder.tagnum = -1 ;
  G__G__Geom1LN_TGeoVoxelFinder.tagnum = -1 ;
  G__G__Geom1LN_TGeoManager.tagnum = -1 ;
  G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes.tagnum = -1 ;
  G__G__Geom1LN_TGeoVolumeMulti.tagnum = -1 ;
  G__G__Geom1LN_TGeoVolumeAssembly.tagnum = -1 ;
  G__G__Geom1LN_TGeoNodecLcLdA.tagnum = -1 ;
  G__G__Geom1LN_TGeoNodeMatrix.tagnum = -1 ;
  G__G__Geom1LN_TGeoNodeOffset.tagnum = -1 ;
  G__G__Geom1LN_TGeoIterator.tagnum = -1 ;
  G__G__Geom1LN_TGeoIteratorPlugin.tagnum = -1 ;
  G__G__Geom1LN_TGeoVoxelFindercLcLEVoxelsType.tagnum = -1 ;
  G__G__Geom1LN_TGeoPara.tagnum = -1 ;
  G__G__Geom1LN_TGeoTube.tagnum = -1 ;
  G__G__Geom1LN_TGeoTubeSeg.tagnum = -1 ;
  G__G__Geom1LN_TGeoCtub.tagnum = -1 ;
  G__G__Geom1LN_TGeoTorus.tagnum = -1 ;
  G__G__Geom1LN_TGeoSphere.tagnum = -1 ;
  G__G__Geom1LN_TGeoEltu.tagnum = -1 ;
  G__G__Geom1LN_TGeoHype.tagnum = -1 ;
  G__G__Geom1LN_TGeoCone.tagnum = -1 ;
  G__G__Geom1LN_TGeoConeSeg.tagnum = -1 ;
  G__G__Geom1LN_TGeoPcon.tagnum = -1 ;
  G__G__Geom1LN_TGeoPgon.tagnum = -1 ;
  G__G__Geom1LN_TGeoArb8.tagnum = -1 ;
  G__G__Geom1LN_TGeoArb8cLcLEGeoArb8Type.tagnum = -1 ;
  G__G__Geom1LN_TGeoTrap.tagnum = -1 ;
  G__G__Geom1LN_TGeoGtra.tagnum = -1 ;
  G__G__Geom1LN_TGeoTrd1.tagnum = -1 ;
  G__G__Geom1LN_TGeoTrd2.tagnum = -1 ;
  G__G__Geom1LN_TGeoCacheState.tagnum = -1 ;
  G__G__Geom1LN_TGeoNodeCache.tagnum = -1 ;
  G__G__Geom1LN_TGeoNavigator.tagnum = -1 ;
  G__G__Geom1LN_TVirtualGeoTrack.tagnum = -1 ;
  G__G__Geom1LN_TGeoPhysicalNode.tagnum = -1 ;
  G__G__Geom1LN_TGeoPNEntry.tagnum = -1 ;
  G__G__Geom1LN_TVirtualGeoPainter.tagnum = -1 ;
  G__G__Geom1LN_THashList.tagnum = -1 ;
  G__G__Geom1LN_TGeoCompositeShape.tagnum = -1 ;
  G__G__Geom1LN_TGeoShapeAssembly.tagnum = -1 ;
  G__G__Geom1LN_TGeoScaledShape.tagnum = -1 ;
  G__G__Geom1LN_TStopwatch.tagnum = -1 ;
  G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisLevel.tagnum = -1 ;
  G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisOption.tagnum = -1 ;
  G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoBombOption.tagnum = -1 ;
  G__G__Geom1LN_TGeoPolygon.tagnum = -1 ;
  G__G__Geom1LN_TGeoPolygoncLcLdA.tagnum = -1 ;
  G__G__Geom1LN_TGeoXtru.tagnum = -1 ;
  G__G__Geom1LN_TGeoPhysicalNodecLcLdA.tagnum = -1 ;
  G__G__Geom1LN_TGeoPNEntrycLcLEPNEntryFlags.tagnum = -1 ;
  G__G__Geom1LN_TGeoHelix.tagnum = -1 ;
  G__G__Geom1LN_TGeoHelixcLcLEGeoHelixTypes.tagnum = -1 ;
  G__G__Geom1LN_TGeoParaboloid.tagnum = -1 ;
  G__G__Geom1LN_TGeoHalfSpace.tagnum = -1 ;
  G__G__Geom1LN_TGeoBuilder.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Geom1() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TClass);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TObject);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TString);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TList);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TBrowser);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TObjArray);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoAtt),sizeof(TGeoAtt),-1,296192,"class for visibility, activity and optimization attributes for volumes/nodes",G__setup_memvarTGeoAtt,G__setup_memfuncTGeoAtt);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoAttcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoAttcLcLEGeoVisibilityAtt);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoAttcLcLEGeoActivityAtt);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoAttcLcLEGeoOptimizationAtt);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoAttcLcLEGeoSavePrimitiveAtt);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoShape),sizeof(TGeoShape),-1,324889,"base class for shapes",G__setup_memvarTGeoShape,G__setup_memfuncTGeoShape);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoMatrix),sizeof(TGeoMatrix),-1,327429,"base geometrical transformation class",G__setup_memvarTGeoMatrix,G__setup_memfuncTGeoMatrix);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoHMatrix),sizeof(TGeoHMatrix),-1,326912,"global matrix class",G__setup_memvarTGeoHMatrix,G__setup_memfuncTGeoHMatrix);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoBoolNode),sizeof(TGeoBoolNode),-1,327433,"a boolean node",G__setup_memvarTGeoBoolNode,G__setup_memfuncTGeoBoolNode);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoBoolNodecLcLEGeoBoolType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoUnion),sizeof(TGeoUnion),-1,324864,"union node",G__setup_memvarTGeoUnion,G__setup_memfuncTGeoUnion);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoIntersection),sizeof(TGeoIntersection),-1,324864,"intersection node",G__setup_memvarTGeoIntersection,G__setup_memfuncTGeoIntersection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoSubtraction),sizeof(TGeoSubtraction),-1,324864,"subtraction node",G__setup_memvarTGeoSubtraction,G__setup_memfuncTGeoSubtraction);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TAttFill);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TAttLine);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TAttMarker);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoElementTable),sizeof(TGeoElementTable),-1,327424,"table of elements",G__setup_memvarTGeoElementTable,G__setup_memfuncTGeoElementTable);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoIsotope),sizeof(TGeoIsotope),-1,324864,"Isotope class defined by Z,N,A",G__setup_memvarTGeoIsotope,G__setup_memfuncTGeoIsotope);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoElement),sizeof(TGeoElement),-1,327424,"base element class",G__setup_memvarTGeoElement,G__setup_memfuncTGeoElement);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoElementcLcLEGeoElement);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoDecayChannel),sizeof(TGeoDecayChannel),-1,327424,"Decay channel for Elements",G__setup_memvarTGeoDecayChannel,G__setup_memfuncTGeoDecayChannel);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoBatemanSol),sizeof(TGeoBatemanSol),-1,327424,"Solution for the Bateman equation",G__setup_memvarTGeoBatemanSol,G__setup_memfuncTGeoBatemanSol);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoElementRN),sizeof(TGeoElementRN),-1,327424,"radionuclides class",G__setup_memvarTGeoElementRN,G__setup_memfuncTGeoElementRN);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoDecayChannelcLcLENuclearDecayMode);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoBatemanSolcLcLBtCoef_t);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoElemIter),sizeof(TGeoElemIter),-1,298752,"Iterator for radionuclide chains.",G__setup_memvarTGeoElemIter,G__setup_memfuncTGeoElemIter);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_maplEintcOTGeoElementRNmUcOlesslEintgRcOallocatorlEpairlEconstsPintcOTGeoElementRNmUgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoElementTablecLcLEGeoETStatus);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoMaterial),sizeof(TGeoMaterial),-1,327424,"base material class",G__setup_memvarTGeoMaterial,G__setup_memfuncTGeoMaterial);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterial);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoMaterialcLcLEGeoMaterialState);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoMixture),sizeof(TGeoMixture),-1,327424,"material mixtures",G__setup_memvarTGeoMixture,G__setup_memfuncTGeoMixture);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoMedium),sizeof(TGeoMedium),-1,327424,"tracking medium",G__setup_memvarTGeoMedium,G__setup_memfuncTGeoMedium);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoMediumcLcLEGeoMedium);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoMatrixcLcLEGeoTransfTypes);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoTranslation),sizeof(TGeoTranslation),-1,327424,"translation class",G__setup_memvarTGeoTranslation,G__setup_memfuncTGeoTranslation);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoRotation),sizeof(TGeoRotation),-1,327424,"rotation class",G__setup_memvarTGeoRotation,G__setup_memfuncTGeoRotation);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoScale),sizeof(TGeoScale),-1,325376,"scaling class",G__setup_memvarTGeoScale,G__setup_memfuncTGeoScale);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoCombiTrans),sizeof(TGeoCombiTrans),-1,327424,"rotation + translation",G__setup_memvarTGeoCombiTrans,G__setup_memfuncTGeoCombiTrans);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoGenTrans),sizeof(TGeoGenTrans),-1,324864,"rotation + translation + scale",G__setup_memvarTGeoGenTrans,G__setup_memfuncTGeoGenTrans);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoIdentity),sizeof(TGeoIdentity),-1,324864,"identity transformation class",G__setup_memvarTGeoIdentity,G__setup_memfuncTGeoIdentity);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TAtt3D);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoBBox),sizeof(TGeoBBox),-1,324864,"box primitive",G__setup_memvarTGeoBBox,G__setup_memfuncTGeoBBox);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoVolume),sizeof(TGeoVolume),-1,130816,"geometry volume descriptor",G__setup_memvarTGeoVolume,G__setup_memfuncTGeoVolume);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TBuffer3D);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoShapecLcLEShapeType);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TH2F);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoNode),sizeof(TGeoNode),-1,327425,"base class for all geometry nodes",G__setup_memvarTGeoNode,G__setup_memfuncTGeoNode);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoPatternFinder);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoVoxelFinder),sizeof(TGeoVoxelFinder),-1,130816,"voxel finder class",G__setup_memvarTGeoVoxelFinder,G__setup_memfuncTGeoVoxelFinder);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoManager),sizeof(TGeoManager),-1,130816,"geometry manager",G__setup_memvarTGeoManager,G__setup_memfuncTGeoManager);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoVolumecLcLEGeoVolumeTypes);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoVolumeMulti),sizeof(TGeoVolumeMulti),-1,327424,"class to handle multiple volumes in one step",G__setup_memvarTGeoVolumeMulti,G__setup_memfuncTGeoVolumeMulti);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoVolumeAssembly),sizeof(TGeoVolumeAssembly),-1,324864,"an assembly of volumes",G__setup_memvarTGeoVolumeAssembly,G__setup_memfuncTGeoVolumeAssembly);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoNodecLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoNodeMatrix),sizeof(TGeoNodeMatrix),-1,327424,"a geometry node in the general case",G__setup_memvarTGeoNodeMatrix,G__setup_memfuncTGeoNodeMatrix);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoNodeOffset),sizeof(TGeoNodeOffset),-1,327424,"a geometry node with just an offset",G__setup_memvarTGeoNodeOffset,G__setup_memfuncTGeoNodeOffset);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoIterator),sizeof(TGeoIterator),-1,36608,"Iterator for geometry.",G__setup_memvarTGeoIterator,G__setup_memfuncTGeoIterator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoIteratorPlugin),sizeof(TGeoIteratorPlugin),-1,32513,"ABC for user plugins connecter to a geometry iterator.",G__setup_memvarTGeoIteratorPlugin,G__setup_memfuncTGeoIteratorPlugin);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoVoxelFindercLcLEVoxelsType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoPara),sizeof(TGeoPara),-1,324864,"box primitive",G__setup_memvarTGeoPara,G__setup_memfuncTGeoPara);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoTube),sizeof(TGeoTube),-1,324864,"cylindrical tube class",G__setup_memvarTGeoTube,G__setup_memfuncTGeoTube);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoTubeSeg),sizeof(TGeoTubeSeg),-1,324864,"cylindrical tube segment class ",G__setup_memvarTGeoTubeSeg,G__setup_memfuncTGeoTubeSeg);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoCtub),sizeof(TGeoCtub),-1,324864,"cut tube segment class ",G__setup_memvarTGeoCtub,G__setup_memfuncTGeoCtub);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoTorus),sizeof(TGeoTorus),-1,324864,"torus class",G__setup_memvarTGeoTorus,G__setup_memfuncTGeoTorus);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoSphere),sizeof(TGeoSphere),-1,324864,"sphere class",G__setup_memvarTGeoSphere,G__setup_memfuncTGeoSphere);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoEltu),sizeof(TGeoEltu),-1,324864,"elliptical tube class",G__setup_memvarTGeoEltu,G__setup_memfuncTGeoEltu);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoHype),sizeof(TGeoHype),-1,324864,"hyperboloid class",G__setup_memvarTGeoHype,G__setup_memfuncTGeoHype);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoCone),sizeof(TGeoCone),-1,324864,"conical tube class",G__setup_memvarTGeoCone,G__setup_memfuncTGeoCone);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoConeSeg),sizeof(TGeoConeSeg),-1,324864,"conical tube segment class ",G__setup_memvarTGeoConeSeg,G__setup_memfuncTGeoConeSeg);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoPcon),sizeof(TGeoPcon),-1,327424,"polycone class ",G__setup_memvarTGeoPcon,G__setup_memfuncTGeoPcon);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoPgon),sizeof(TGeoPgon),-1,324864,"polygone class ",G__setup_memvarTGeoPgon,G__setup_memfuncTGeoPgon);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoArb8),sizeof(TGeoArb8),-1,130816,"arbitrary trapezoid with 8 vertices",G__setup_memvarTGeoArb8,G__setup_memfuncTGeoArb8);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoArb8cLcLEGeoArb8Type);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoTrap),sizeof(TGeoTrap),-1,324864,"G3 TRAP shape",G__setup_memvarTGeoTrap,G__setup_memfuncTGeoTrap);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoGtra),sizeof(TGeoGtra),-1,324864,"G3 GTRA shape",G__setup_memvarTGeoGtra,G__setup_memfuncTGeoGtra);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoTrd1),sizeof(TGeoTrd1),-1,324864,"TRD1 shape class",G__setup_memvarTGeoTrd1,G__setup_memfuncTGeoTrd1);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoTrd2),sizeof(TGeoTrd2),-1,324864,"TRD2 shape class",G__setup_memvarTGeoTrd2,G__setup_memfuncTGeoTrd2);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoCacheState);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoNodeCache);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoNavigator),sizeof(TGeoNavigator),-1,327424,"geometry navigator class",G__setup_memvarTGeoNavigator,G__setup_memfuncTGeoNavigator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TVirtualGeoTrack),sizeof(TVirtualGeoTrack),-1,327433,"virtual geometry tracks",G__setup_memvarTVirtualGeoTrack,G__setup_memfuncTVirtualGeoTrack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoPhysicalNode),sizeof(TGeoPhysicalNode),-1,327424,"base class for physical nodes",G__setup_memvarTGeoPhysicalNode,G__setup_memfuncTGeoPhysicalNode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoPNEntry),sizeof(TGeoPNEntry),-1,327424,"a physical node entry with unique name",G__setup_memvarTGeoPNEntry,G__setup_memfuncTGeoPNEntry);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TVirtualGeoPainter),sizeof(TVirtualGeoPainter),-1,324682,"Abstract interface for geometry painters",G__setup_memvarTVirtualGeoPainter,G__setup_memfuncTVirtualGeoPainter);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_THashList);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoCompositeShape),sizeof(TGeoCompositeShape),-1,327424,"boolean composite shape",G__setup_memvarTGeoCompositeShape,G__setup_memfuncTGeoCompositeShape);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoShapeAssembly),sizeof(TGeoShapeAssembly),-1,324864,"assembly shape",G__setup_memvarTGeoShapeAssembly,G__setup_memfuncTGeoShapeAssembly);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoScaledShape),sizeof(TGeoScaledShape),-1,324864,"a scaled shape",G__setup_memvarTGeoScaledShape,G__setup_memfuncTGeoScaledShape);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TStopwatch);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisLevel);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoVisOption);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TVirtualGeoPaintercLcLEGeoBombOption);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoPolygon),sizeof(TGeoPolygon),-1,324864,"class for handling arbitrary polygons",G__setup_memvarTGeoPolygon,G__setup_memfuncTGeoPolygon);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoPolygoncLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoXtru),sizeof(TGeoXtru),-1,130816,"extruded polygon class ",G__setup_memvarTGeoXtru,G__setup_memfuncTGeoXtru);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoPhysicalNodecLcLdA);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoPNEntrycLcLEPNEntryFlags);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoHelix),sizeof(TGeoHelix),-1,324864,"helix class",G__setup_memvarTGeoHelix,G__setup_memfuncTGeoHelix);
   G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoHelixcLcLEGeoHelixTypes);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoParaboloid),sizeof(TGeoParaboloid),-1,324864,"paraboloid class",G__setup_memvarTGeoParaboloid,G__setup_memfuncTGeoParaboloid);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoHalfSpace),sizeof(TGeoHalfSpace),-1,324864,"half-space class",G__setup_memvarTGeoHalfSpace,G__setup_memfuncTGeoHalfSpace);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Geom1LN_TGeoBuilder),sizeof(TGeoBuilder),-1,32512,"geometry builder singleton",G__setup_memvarTGeoBuilder,G__setup_memfuncTGeoBuilder);
}
extern "C" void G__cpp_setupG__Geom1(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Geom1()");
  G__set_cpp_environmentG__Geom1();
  G__cpp_setup_tagtableG__Geom1();

  G__cpp_setup_inheritanceG__Geom1();

  G__cpp_setup_typetableG__Geom1();

  G__cpp_setup_memvarG__Geom1();

  G__cpp_setup_memfuncG__Geom1();
  G__cpp_setup_globalG__Geom1();
  G__cpp_setup_funcG__Geom1();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Geom1();
  return;
}
class G__cpp_setup_initG__Geom1 {
  public:
    G__cpp_setup_initG__Geom1() { G__add_setup_func("G__Geom1",(G__incsetup)(&G__cpp_setupG__Geom1)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Geom1() { G__remove_setup_func("G__Geom1"); }
};
G__cpp_setup_initG__Geom1 G__cpp_setup_initializerG__Geom1;

---